Planet Source Code Jumbo …e CD Visual Basic 1 to 7/6_2008-2009.ISO/data/zips/How_to_use2150884272009.psc/Ash-Sha1 MD5/C source (test).txt

C/C++ Source or Header | 2009-04-28 | 1MB | 50,057 lines

#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );

#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );

#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );

#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );

#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );

#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );

#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );

#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );


#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );

#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );




#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s\n\n", MDxGetVersion());

    if( argc > 1 )
        DigestFile( argv[1] );
    else
        DigestString();

}

/*
    I use the 'chunk' method for processing files not because of
    limitations of my dll, but think what would happen if you
    tried to load an entire cd image into memory.
*/
void DigestFile( char *szFName )
{
    FILE *file;
    void *lpData;
    long flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file == NULL )
    {
        printf("ERROR: File not found.\n");
        return;
    }

    MDxInit( &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);
    = strlen(lpData);
    = strlen(lpData);
    = strlen(lpData);
    = strlen(lpData);
    = strlen(lpData);
    = strlen(lpData);
    = strlen(lpData);
    = strlen(lpData);
    = strlen(lpData);
    = strlen(lpData);
    = strlen(lpData);Data) &mdDataSum );
    MDxInit( &md4DataSum );

    fseek( file, 0, SEEK_END );
    //Get the file length
    flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunth
    flen = ntf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#eROR!\n");
            return;
        }



---------ng DWORD;
        #define STDCALL _stdcall
#eROR!\n");
            return;
        }



---------ng DWORD;
        #define STDCALL _stdcall
#eROR!\n");
            return;
        }



---------ng DWORD;
        #define STDCALL _stdcall larSTDCALL _stdcall
#eROR!\n");
            return;
        }



---------ng DWORD;
        #define STDCALL _stdcall larSTDCALL _stdcall
#eROR!\n");
            return;
        }



---------ng DWORD;
        #define STDCALL _stdcall larSTTTTTTTTTTTTTTTTlong flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 Digests of \"%s\":\n", szFName );

    file = fopen( szFName, "rb" );
    if( file ==     // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary because of the 'chunking' method
    MDxFinalize( &mdDataSum );
    MDxFinalize( &md4DataSum );

    printf("\nMD4: %08x%08x%08x%08x\n", md4DataSum.dwSum[0], md4DataSum.dwSum[1], md4DataSum.dwSum[2], md4DataSum.dwSum[3]);
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);
    fclose(file);

}

void DigestString()
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the strings, we're gonna pad and digest the string
    // in one pass.
    MDxInit( &mdDataSum );
    MDxPad( lpData, len, len );

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    MDxInit( &mdDataSum );
    MD4Translate( lpData, len, &mdDataSum );
    printf("MD4: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf(     }



---------ng DWORD;
        #define STDCALL _stdcall larSTTTTTTTTTTTTTTTTlong flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 run
    // th > READLEN )
 );

void main(int argc, char *argv[])
{
    printf("%s
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enter the string to digest: ");
  (lpData);
    = strlen(lpData);
    = strlen(lpData);
    = strlen(lpData);
    = strlen(lpData);
    = strlen(lpData);
    = strlen(lpData);
    = strlen(lpData);
    = strlen(lpData);
    = strlen(lpData);Data) &mdDataSum );
    MDxInit(        if( fread( lpData, 1, READLEN, file ) method
    MDxTTTTTT{
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpDaigned char lpDaE.-----ng DWORD;
        #define STDCALL _stdcall
#eROR!\n");
            return;
        }



---------ng DWORD;
        #define STDCALL _stdcall larSTDCALL _stdcall
#eROR!\n");
            return;
        }



---------ng DWORD;
       g szFName, "rb" );
    if( file ==     // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != flen = mlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, READLEN, &md4DataSum );
        flen -= READLEN;
        printf(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary beca

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataS    printf("READ ERROR!\n"}    priurn;
        }



---------ng DWORD;
        #define STDCALL _stdcall larSTDCALL _stdcall
#eROR!\n");
            return;
        }



---------ng DWORD;
       g szFName, "rb" );
    if( file ==     // remember that for each chunk it hasa

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the stDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void Diges  while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, a\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataSum.dwSum[3]);

    return;
}


-------------- Include

#ifndef __windows_h__
        typedef unsigned long DWORD;
        #define STDCALL _stdcall
#endif

typedef struct
{
    DWORD dwSum[4];
}MDxSum;

DWORD STDCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf(     }



---------ng DWORD;
        #define STDCALL _stdcall larSTTTTTTTTTTTTTTTTlong flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 run
    // th > READLEN )
 );

void main(int argc, char *argv[])
{
    printf("%s
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enterlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %l * );
void DigestString();

void main(int argc, char *argv[])
{
    printf("%s
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf(     }
  bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf(     }
  bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf(     }
  bigger tember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData ER!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData ER!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData ER!\n");m(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary beca

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataS    printf("READ ERROR!\n"}    priurn;
        }



---------ng DWORD;
        #define STDCALL _stdcall larSTDCALL _stdcall
#eROR!\n");
            return;
        }



---------ng DWORD;
       g szFName, "rb" );
    if( file ==     // remember that for each chunk it hasa

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the stDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdADLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, a\n", mdDataSum.dw



---------ng DWORD;
       g szFName, "rb" );
    if( file ==     // remember that for each chunk it hasa

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before theter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before theter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before theter the mCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

voir lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf(     }



---------ng DWORD;
        #define STDCALL _stdcall larSTTTTTTTTTTTTTTTTlong flen, mlen;
    MDxSum mdDataSum;
    MDxSum md4DataSum;

    // the 64 is for padned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, or padding purposes
    lpData = malloc( READLEN + 64 );

    printf( "MD4/5 run
    // th > READLEN )
 );

void main(int argc, char *argv[])
{
    printf("%s
{

    //For our demo purposes, no strings bigger than 1024 :)
    unsigned char lpData[1024] = "";
    long len = 0;
    MDxSum mdDataSum;

    printf("Enterlen = ftell( file );
    fseek( file, 0, SEEK_SET );

    // When it takes a while to process a large file,
    // remember that for each chunk it has to run
    // throu READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN,the pE7Data, READLEN, &mdDataSum );
        MD4Translate( lpData ER!\n");m(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can p( lpData, 1, fl   return;
    }
    // This is why I added the new argument to MDxPad
    // So we can p( lpData, 1, fl   return;
    }
    // This is why I added the new argument to MDxPad
    // So we can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the new argument to MDxPad
    // So we can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the new argument to MDxPad
    // So we can p( lpData, 1, fl   return;
    }
    // This is why I addeta EhiThis is why I a;
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files tha
    // So we can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the new argument to MDxPad
    // So we can p( lpData, 1, fl   return;
    }
    // This is why I addeta EhiThis is why I a;
        return;
    }
   _ADLEN)    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate(;
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData ER!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData ER!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData ER!\n");m(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files that are an exact multiple of the chunk
    // length. (Otherwise the padding isn't Translated)
    flen += MDxPad( lpData, flen, mlen );
    MD5Translate( lpData, flen, &mdDataSum );
    MD4Translate( lpData, flen, &md4DataSum );

    // New step necessary beca

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0], mdDataSum.dwSum[1], mdDataSum.dwSum[2], mdDataS    printf("READ ERROR!\n"}    priurn;
        }



---------ng DWORD;
        #define STDCALL _stdcall larSTDCALL _stdcall
#eROR!\n");
            return;
        }



---------ng DWORD;
       g szFName, "rb" );
    if( file ==     // remember that for each chunk it hasa

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the stDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdADLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, a\n", mdDataSum.dw



---------ng DWORD;
       g szFName, "rb" );
    if( file ==     // remember that for each chunk it hasa

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before theter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before theter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before theter the mCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

void DigestFile( char * );
void DigestString();

voir lpData[o we can p( lpData, 1, fl   return;
    }
    // This is why I added the new argument to MDxPad
    // So we can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the new argument to MDxPad
    // So we can p( lpData, 1,  // So we can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the new argument to MDxPad
    // So we can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the new argument to MDxPad
    /nslate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData ER!\n");m(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to M       MD5Translate( lpData, READLEN,the pE7Data, READLEN, &mdDataSum );
        MD4Translate( lpData ER!\n");m(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This isV can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the new argument to MDxPad
    // So we can p( lpData, 1, fl   return;
    }
    // This is why I addeta EhiThis is why I a;
        return;
    }
    // This is why I added the new argument to MDxPad
    // So we can pass the length of the data AND the
    // Total length of the message
    // Also it now returns the # of padding bytes added,
    // this is for files tha
    // So we can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the new argument to MDxPad
    // So we can p( lpData, 1, fl   return;
    }
    // This is why I addeta EhiThis is why I a;
        return;
    }
   _ADLEN)    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate(;
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData ER!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData ER!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData ER!\n");m(".");
    }

    if (fread( lpData, 1, flen, fileead( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate(;
            return;
        }
        MD5Translate( flen, file ) !=kn = strlen(lpData);

    // Have to do this before theter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before theter the string to digest: ");
    scanf("%s", &lpData );
    len = strlrlen(lpData);ber that for eave to do this ba

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before theter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before theter the string to digest: ");
    ta, 1, fl   ret, &md4DataSum );

    // New step necessary beca

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0E7D4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

voiiiiiiiiiiiiiiii
    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the stDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#includ  }
  bigger tember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, fil
    // For the stDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#includ  }
  bigger tember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printfude "mdADLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, a\n", mdDataSum.dw



---------ng DWORD;
       g szFName, "rb" );
    if( file ==     // remember that for each chunk it hasa

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before theter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before theter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before theter the mCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGurn;
    }
    // This isV can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the new argument to MDxPad
    // So we can p( lpData, 1, fl   return;
    }
    // This is why I addeta EhiThis is why I a;
        retur( lpDaoir lpData[o we can p( lpData, 1, fl   return;
    }
    // This is why I added the new argument to MDxPad
    // So we can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the new argument to MDxPad
    // So we can p( lpData, 1,  // So we can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the new argument to MDxPad
    // So we can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the new argument to MDxPad
    /nslate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData ER!\n");m(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to M       MD5Translate( lpData, READLEN,the pE7Data, READLEN, &mdDataSum );
        MD4Translate( lpData ER!\n");m(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This isV can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the new argument to MDxPad
    // So we can p( lpData, 1, fl   return;
    }
    // This is why I addeta EhiThis is why I a;
        return;
    }
    // This i 1, flen, fileead( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate(;
            return;
        }
         // spData, _;
        MD4Translate( lpData ER!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData ER!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData ER!\n");m(".");
    }

    if (fread( lpData, 1, flen, fileead( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate(;
            return;
        }
        MD5Translate( flen, file ) !=kn = strlen(lpData);

    // Have to do this before theter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before theter the string to digest: ");
    scanf("%s", &lpData );
    len = strlrlen(lpData);ber that for eave to do this ba

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before theter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before theter the string to digest: ");
    ta, 1, fl   ret, &md4DataSum );

    // New step necessary beca

    MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0E7D4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#include "mdx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

voiiiiiiiiiiiiiiii
    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the stDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#includ  }
  bigger tember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printf("Processing %ld byte file: .", flen );

    while( flen > READLEN )
    {
        if( fread( lpData, 1, READLEN, fil

            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, a\n", mdDataSum.dw



---------ng DWORD;
       g szFName, "rb" );
    if( file ==     // reme--ng DWORD;
       g szFName, "rb" );
    if( file ==     // reme--ng DWORD;
       g szFName, "rb" );
    if( file ==     // reme--ng DWORD;
       g szFName, "rb" );
    if( file ==     // reme--ng DWORD;
       g szFName, "rb" );
    if( file ==  k szFNamg szFName, "rb" );
    if( file ==     // reme--ng DWORD;
       g szFName, "rb" );
    if( file ==  k szFNamg szFName, "rb" );
    if( file ==     // reme--ng DWORD;
       g szFName, "rb" );
    if( file ==  k szFNamg szFName, "rb" );
    if( file =k     //
    lud  }
  bigger tember that for each chunk it has to run
    // through the main translation loop 16384 times!

    printfude "mdADLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData, a\n", mdDataSum.dw



---------ng DWORD;
       g szFName, "rb" );
    if( file ==     // remember that for each chunk it hasa

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before theter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before theter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before theter the mCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGurn;
    }
    // This isV can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the ne if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to M       MD5Translate( lpData, READLEN,the pE7Data, READLEN, &mdDataSum );
        MD4Translate( lpDsxGurn;
    }
    // This isV can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the ne if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I ad    scanf("%s", why
    len = strlrlen(lpData);b, 1, flen, fileREADLEN, &mdDataSum );
        MD4Translate( lpData ER!\n");m(".");
    }

    if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("READ ERROR!\n");
        return;
    }
    // This is why I added the new argument to M       MD5Translve to do this before theter the string to dig    {
        y I added the new argument to M       MD5Translve to do this before theter the string to dig    {
        y I added the new argument to M       MD5Translve to do this before theter the string to dig    {
        y I added the new argument to M       MD5Tra  scto M       MD5Translve to do this before theter the string to dig    {
        y I added the new argument to M       MD5Tra  scto M       MD5Translve to do this before theter the string to dig    {
        y I added the new argument to M       MD5Tra  sctone READLEN    1048576L // 2^20, 1MB

voiiiiiiiiiiiiiiii
    // Have to do this beforun
    // thk.well...it's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the stDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#includ  }
  bigger tember that for each chunk it has tember that forent to M       MD5Translve to do thh"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

voiiiiiiiiiiiiiiii
    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digest\"%s\":E7late( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGurn;
    }
    // This isV can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the ne if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the new argument to MDxPad
    // So we can p( lpData, 1,  // So we can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the new argumenn p( lpData, 1,  // So we can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the new argumenn p( lpData, 1,  // So we can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the new argumenn in translation added the new a  MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSum );
    printf("MD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0E7D4Translate( unsigned char *, long, MDxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is Dxnsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translaring to dig    kr *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGurn;
    }
    // This isV can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the ne if (fread( lpData, 1, fded the ne if (g, MDxSum * );
const chate( lpData= strlen(lpData);

    // Have to do this before theter the mCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unchar *,E7um * );
const char * STDCALL MDxGurn;
    }
    // This isV can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the ne if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("can p( lpData, 1, fl   return;
         MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData ER!\n");m(".");
    }

    if (fread( lpData, 1, flen, fileead( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            returna, 1, flen, fileead( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            returna, 1, flen, fileead( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            returna, I added the ne;
             chunk it hasa

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before theter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

    // ERRO);

    // Hav     MD5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

    // ERRO);

    // Hav     MD5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

    // ERRO);iiiiiii
    // Have to do this before the Padding...well...it's best anyway;)
    pr


----&mdDkest\"%s\":E7late( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGurn;
    }
    // This isV can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the ne if (fread( lpData, 1, flen, file ) != flen)
    {
    flen, file ) !=Data);

    // Hav     MD5Traude <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

voiiiiiiiiiiiiiiii
    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digest\"%s\":E7late( unsigned char *, long, MDxSum * );char * E7Gurn;
    }
    // This isV can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the ne if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("can p( lpData, 1, fl   return;
         MD5Translate( lpData, REAn translation loop 16384 times!

    printfude "mdADLEN )
    {
        if( fread( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdEN( unsigned char lpData, READLE's best anyway;)
    printf( "MD4/5 Digests of \n\"%s\":\n", lpData );

    // For the stDxSum * );
const char * STDCALL MDxGetVersion();
void STDCALL MDxFinalize( MDxSum * );



#includ  }
  bigger tember that for each chunk it has tember tha* );
const is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember tha* );
const is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember tha* );
const is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannk it has tember tha* );
const is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannk it has tember tha* );
const is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is Dxnsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translaring to dig    kr *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSumlong, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannk it has tember tha* );
const is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the new argumenn in translation added the new a  MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSuMD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0E7D4Translate( unsigned char *, long, MDxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is Dxnsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translaring to dig    kr *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGurn;
    }
    // This isV can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the ne if (fread( lpData, 1, fded the ne if (g, MDxSum * );
const chate( lpData= strlen(lpData);

    // Have to do this before theter the mCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unchar *,E7um * );
const char * STDCALL MDxGurn;
    }
    // This isV can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the ne if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("can p( lpData, 1, fl   return;
         MD5Translate( lpData, READLEN, &mdDataSum );
        MD4Translate( lpData ER!\n");m(".");
    }

    if (fread( lpData, 1, flen, fileead( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            returna, 1, flen, fileead( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            returna, 1, flen, fileead( lpData, 1, READLEN, file ) != READLEN)
        {
            printf("READ ERROR!\n");
            returna, I added the ne;
             chunk it hasa

    printf("Enter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Have to do this before theter the string to digest: ");
    scanf("%s", &lpData );
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

    // ERRO);

    // Hav     MD5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

    // ERRO);

    // Hav     MD5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

    // ERRO);iiiiiii
    // Have to do this before the Padding...well...it's best anyway;)
    pr


----&mdDkest\"%s\":E7late( unsigned char *, long, MDxSum * );
const char * STDCALL MDxGurn;
    }
    // This isV can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the ne if (fread( lpData, 1, flen, file ) != flen)
    {
    flen, file ) !=Data);

    // Hav     MD5Traude <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

voiiiiiiiiiiiiiiii
    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digest\"%s\":E7late( unsigned char *, long, MDxSum * );char * E7Gurn;
    }
    // This isV can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the ne if (fread( lpData, 1, flen, file ) != flen)
    {

            return;
        }
        MD5Translate( lpData, READLEN, &mdEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdEN)
        {
            printf("READ ERROR!\n");
 lpData, READLEN, &mdEN)
        {
            printf("READ ERROR!\n");
 lpData, READLEN, &mdEN)
        {
            printf("READ ERROR!\n");
 lpData, READLEN, &mdEN)
        {
            printf("READ ERROR!\n");
 lpData, READLEN, &mdEN)
       ha* );
const is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is Dxnsigned long, unsigned long );
void STDCALL MDxInit( MDxSu=rannkunk it has temb

----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is Dxnsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translaring to dig    kr *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSumlong, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannk it has tember tha* );
const is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the new argumenn in translation added the new a  MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSuMD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0E7D4Translate( unsigned char *, long, MDxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDat is why I added the new argumenn in translation added the new a  MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSuMD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0E7D4Translate(n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is DxSum * );
const chate( lpData, a\n"long, MDxSum * );
const is DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is Dxnsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translaring to ding, MD * );
const char * STDCALL MDxGurn;
    }
    // This isV can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the ne if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("can p( lpData, 1, fl   return;

const char * * );
const char * STDCALL MDxGurn;
    }
    // This isV can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the ne if (fread( lpData, 1, fded the ne if (g, MDxSum * );
const chate( lpData= strlen(lpData);

    // Have to do this before theter the mCALL MDxPad ( unsigned char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unchar *,E7um * );
const char * STDCALL MDxGurn;
    }
    // This isV can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the ne if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("can p( lpData, 1, fl   return;
         MD5Translate(
    // Hav     MD5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN  // This isV can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the ne if (fread( lpData, 1, flen, file ) != flen)
    {
        printf("can p( lpData, 1, fl   return;
         MD5Translate(
    // Hav     MD5Tra  scrn;
MD5Tra  scREADLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

    // ERRO);

    // Hav     MD5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

    // ERRO);iiiiiii
    // Have to do this befo
    // Hav     MD5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN    1ne READLEN    1ne READLData, 1, flen, file ) != flen)
    {
    flen, file ) !=Data);

    // Hav     MD5Traude <string.h>

// READLEN % 64 must = 0
#define READLEN    1048576L // 2^20, 1MB

voiiiiiiiiiiiiiiii
    // Have to do this before the Padding...well...it's best anyway;)
    printf( "MD4/5 Digest\"%s\":E7late( unsigned char *, long, MDxSum * );char * E7Gurn;
    }
    // This isV can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the ne if (fread( lpData, 1, flen, file ) != flen)
    {

            return;
        }
        MD5Translate( lpData, READLEN, &mdEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lpData, READLEN, &mdEN)
        {
            printf("READ ERROR!\n");
 lpData, READLEN, &mdEN)
        {
            printf("READ ERROR!\n");
 lpData, READLEN, &mdEN)
        {
            printf("READ ERROR!\n");
 lpData, READLEN, &mdEN)
        {
            printf("READ ERROR!\n");
 lpData, READLEN, &mdEN)
       ha* );
const is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is Dxnsigned long, unsigned long );
void STDCALL MDxInit( MDxSu=rannkunk it has temb

----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is Dxnsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translaring to dig    kr *, long, MDxSum * );
void STDCALL MD4Translate( unsigned char *, long, MDxSumlong, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannk it has tember tha* );
const is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the new argumenn in translation added the new a  MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSuMD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0E7D4Translate( unsigned char *, long, MDxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDat is why I added the new argumenn in translation added the new a  MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSuMD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0E7D4Translate(n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is DxSum * d char *, unsigned long, unsigned long );
void STDCALL MDxInit( MDxSum * );
void STDCALL MD5Translate( unsigned char *, long, MDxSum * );
void STDCALL MD4Translate( unchar *,E7um * );
const char * STDCALL MDxGurn;
    }
    // This isV can p( lpData, 1 *, long, MDxSum * );
const is DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is DxSum * );
const chate( lpData, a\n"long, MDxSum * );
const is DxSum * );
const chate( lpData, :lhate( (7   // ERRO);

    // Hav     MD5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

    // ERRO);iiiiiii
    // Have to do this befo
    // Hav     MD5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the new argumenn in translation added tkadded the ne if (fread( lpData, 1, flen, file ) != flen)
    {

            return;
        }
        MD5Translate( lpData, READLEN, &mdEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lthe ne if (frE7Gurn;
    }    {
        V can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the ne if (fread( lpData, 1, flen, file ) != flen)
    {

            return;
        }
        MD5Translate( lpData, READLEN, &mdEN)
        {
            printf("READ ERROR!\n");
            returhas temb

---- Hav     MD5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN  // This isV can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the ne if (fread( lE7EN, &mdEN)
        {
            printf("READ ERROR!\n");
 lpData, READLEN, &mdEN)
       ha* );
const is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is Dxnsigned long, unsigned long );
void STDCALL MDxInit( MDxSu=rannkunk it has temb

----&mdDataSum );
e( unsigned char *, long, MDr *, long, MDxS
        {
            printf("READ ERROR!\n");
 lpData, READLEN, &mdEN)
        {
            printf("READ ERROR!\n");
 lpData, READLEN, &mdEN)
        {
            printf("READ ERROR!\n");
 lpData, READLEN, &mdEN)
       ha* );
const is Dxnsignwhy I added the ne if (fread( lpData, 1, flen, file ) != flen)
    {

            return;
        }
        MD5Translate( lpData, READLEN, &mdEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Transl>I added the new argumenn in translation added the new a  MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSuMD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0E7D4Translate( unsigned char *, long,hate( lpData, a>s is why I addeta Ehis is why I added the new argumenn in translation added tkadded the ne if (fread( lpData, 1, flen, file ) != flen)
    {

            return;
        }
        MD5Translate( lpData, READLEN, &mdEN)
        {
            prikE7D4Translate(n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is DxSum * d char *, unsiganslate(n", mssary because ovoid STDCALL MDctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

    // ERRO);iiiiiii
    // Have to do this befo
    // Hav     MD5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne
e( D ERROR!\n");
 lpData, READLEN, &mdEN)
       ha* );
const is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is Dxnsigned lona\n", mdDataSum.dwSum[0E7D4Translate( unsigned char *, long, MDxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigne;
const is DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDat is why I added the new argumenn in transla, mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDat is why I added the new argumenn in translation added the new a  MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSuMD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0E7D4Translate(n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is DxSum * )    1048576L // 2^ Have to do thi);
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This is whs is a);
void STDCALL MD4Translate( unchar *,E7um * );
const char * STDCALL MDxGurn;
    }
    // This isV can p( lpData, 1 *, long, MDxSum * );
const is DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is DxSum * );
const chate( lpData, a\n"long, MDxSum * );
const is DxSum * );
const chate( lpData, :lhate( (7   // ERRO);

    // Hav     MD5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

    // ERRO);iiiiiii
    // Have to do this befo
    // Hav     MD5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the new argumenn in translation added tkadded the ne if (fread( lpData, 1, flen, file ) != flen)
    {

            return;
        }
        MD5Translate( lpData, READLEN, &mdEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lthe ne if (frE7Gurn;
    }    {
        V can p( lpData, 1, fl   return;
    }
    // This

    // Hav     MD5Tra  sctone READLEN  // This isV can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the ne if (fread( lE7EN, &mdEN)
        {
            printf("READ ERROR!\n");
 lpData, READLEN, &mdEN)
     V can p( lmm     MD5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN  // This isV can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the ne if (fread( lE7EN, &mdEN)
        {
            printf("READ ERROR!\n");
 lpData, READLEN, &mdEN)
       ha* );
const is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is Dxnsigned long, unsigned long );
void STDCALL MDxInit( MDxSu=rannkunk it has temb

----&mdDataSum );
e( unsigned char *, long, MDr *, long, MDxS
        {
            printf("READ ERROR!\n");
 lpData, READLEN, &mdEN)
        {
            printf("READ ERROR!\n");
 lpData, READLEN, &mdEN)
        {
            printf("READ ERROR!\n");
 lpData, READLEN, &mdEN)
       ha* );
const is Dxnsignwhy I added the ne if (fread( lpData, 1, flen, file ) != flen)
    {

            return;
        }
        MD5Translate( lpData, READLEN, &mdEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Transl>I added the new argumenn in translation added the new a  MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSuMD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0E7D4Translate( unsigned char *, long,hate( lpData, a>s is why I addeta Ehis is why I added the new argumenn in translation added tkadded the ne if (fread( lpData, 1, flen, file ) != flen)
    {

            return;
        }
        MD5Translate( lpData, READLEN, &mdEN)
        {
            prikE7D4Translate(n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is DxSum * d char *, unsiganslate(n", mssary because ovoid STDCALL MDctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

    // ERRO);iiiiiii
    // Have to do this befo
    // Hav     MD5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne
e( D ERROR!\n");
 lpData, READLEN, &mdEN)
       ha* );
const is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is Dxnsigned lona\n", mdDataSum.dwSum[0E7D4Translate( unsigned char *, long, MDxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigne;
const is DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDat is why I added the new argumenn in transla, mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDat is why I added the new argumenn in translation added the new a  MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSuMD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0E7D4Translate(n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is DxSum * )    1048576L // 2^ Have to do thi);
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This is whs is a);
void STDCALL MD4Translate( unchar *,E7um * );
const char * STDCALL MDxGurn;
    }
    // This isV can p( lpData, 1 *, long, MDxSum * );
const is DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is DxSum * );
const chate( lpData, a\n"long, MDxSum * );
const is DxSum * );
const chate( lpData, :lhate( (7   // ERRO);

    // Hav     MD5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

    // ERRO);iiiiiii
    // Have to do this befo
    // Hav     MD5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the new argumenn in translation added tkadded the ne if (fread( lpData, 1, flen, file ) != flen)
    {

            return;
        }
        MD5Translate( lpData, READLEN, &mdEN)
        {
            printf("READ ERROR!\n");
            return;
        }
        MD5Translate( lthe ne if (frE7Gurn;
    }    {
        V can p( lpData, 1, fl   return;
    }
    // This

    // Hav     MD5Tra  sctone READLEN  // This isV can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the ne if (fread( lE7EN, &mdEN)
        {
            printf("READ ERROR!\n");
 lpData, READLEN, &mdEN)
     V can p( lmm     MD5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN  // This isV can p( lpData, 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the ne if (fread( lE7EN, &mdEN)
        {
            printf("READ ERROR!\n");
 lpData, READLEN, &mdEN)
       ha* );
const is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is Dxnsigned long, unsigned long );
void STDCALL MDxInit( MDxSu=rannkunk it has temb

----&mdDataSum );
e( unsigned char *, long, MDr *, long, MDxS
        {
            printf("READ ERROR!\n");
 lpData, READLEN, &mdEN)
        {
            printf("READ ERROR!\n");
 lpData, READLEN, &mdEN)
        {
            printf("READ ERROR!\n");
 lpData, READLEN, &mdEN)
       ha* );
const is Dxnsignwhy I added the ne if (fread( lpData, 1, flen, file ) != flen)
    {

            return;
        }
        MD5Translate( lpData, READLEN, &mdEN)
        {
            pri);
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSuMD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0E7D4Translate( unsigned char *, long,hate( lpData, a>s is why I addeta Ehis is why I added the new argumenn in translxSum * );
const is DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is DxSum * d char *, unsiganslate(n", mssary because ovoid STDCALL MDctone READLEN    1048576L // 2^ Have to do tpData);

    // ERRO);iiiiiii
    // Have to do this befo
    // Hav     MD5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne
e( D ERROR!\n");
 lpData, READLEN, &mdEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha*rsion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is Dxnsigned long, unsigned long );
void STDCALL MDxInit( MDxSu=rannkunk it has temb

----&mdDataSum );
e( unsigned  Have to do thi);
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne
e( D ERROR!\n");
 lpData, READLEN, &mdEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha* )GetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is Dxnsigned lona\n", mdDataSum.dwSum[0E7D4Translate( unsigned char *, long, MDxSum * );
const chate( lpData, a\nar *, long, MDxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigne;
const is DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDat is why I added the new argumenn in transla, mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDat is why I added the new argumenn in translation added the new a  MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSuMD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0E7D4Translate(n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is DxSum * )    1048576L // 2^ Have to do thi);
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk 48576L // 2^ Have to do thi);
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This is why I adGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This is why I adGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e(     // Tme ne if (fread( lE7EN, &mdEN)
        {
            printf("READ ERROR!\n");
 lpData, READLEN, &mdEN)
     V can p( lmm     MD5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This is why I adGetVersion()er tember that fEmlation added tkadded the ne if (fread( lpData, 1, flen, file ) != flen)
    {

            return;
        }
        MD5Translate( lpData, READLEN, &mdEN)
        {
            printf("READ ERROR!\n");
            return;
        }
             printf("READ ERROR!\n");
            return;
        }
             printf("READ ERROR!\n");
            return;
        }
             printf("READ ERROR!\n");
            return;
        }
             printf("READ ERROR!\n");
            re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEN)
       ha*rsion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is Dxnsigned long, unsigned long );
void STDCALL MDxInit( MDxSu=rannkunk iboE7 ha* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha*rsion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsigned c      MDxFinalikSum * );
const is Dxnsigned long, unsigned long );
void STDCALL MDxInit( MDxSu=rannkunk it has temb

----&mdDataSum );
e( unsigned  Have to do thi);
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne
e( D ERROR!\n");
 lpData, READLEN, &mdEN)
       ha* )ata, READLEN, &signed long MDxGetVersion()er tembe* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha*rsion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is Dxnsigned long, unsigned long );
DCALL ME76L // 2^ Have to do thi);
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&m 2^ Have to do thi);
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This is whs is a);
void hunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This is whs is a);
void hunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This is whs is a);
void huuMD5: %08x%08x% is whs is a);D5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne
e( D ERROR!\n");
 lpData, READLEN, &mdEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
r that for each chunk it has tember Trannkunkta, READLEN, &mha* );
const iEN)
       ha* );
const iEN)
r that for each chunk it has tember Trannkunkta, READLEN, &mha* );
const iEN)
       ha* );
const iEN)
r that for each chunk it has tember Trannkunkta, READLEN, &mha* );
const iEN)
       ha* );
const iEN   /ha* );
const iEN)
r that for each chunk it has tember Trannkunkta, READLEN, &mha* );
const iEN)
       ha* );
const iEN   /ha* );
const iEN)
r that for each chunk it has tember Trannkunkta, READLEN, &mha* );
const iEN)
       ha* );
const iEN   /haaaaaaaaaaaaaaaadDataSum );
e( unsigned char *, long, MDxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigne;
const is DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDat is why I added the new argumenn in transla, h chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This is why I addeta Ehis is why I added the new argumenn in translation added the new a  MD5Translate( lpData, len, &mdDataSum );
        // New step e new a  MD5Translate( lpData, len, &mdDataSum );
        // New step necessary because of the 'chunking' method
        MDxFinalize( &mdDataSuMD5: %08x%08x%08x%08x\n", mdDataSum.dwSum[0E7D4Translate(n", mdDataSum.dw



----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is DxSum * )    1048576L // 2^ Have to do thi);
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk 48576L // 2^ Have to do thi);
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This is why I adGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This is why I adGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e(     // Tme ne if (fread( lE7EN, &mdEN)
        {
            printf("READ ERROR!\n");
 lpData, READLEN, &mdEN)
     V can p( lmm     MD5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This is why I adGetVersion()er tember that fEmlation added tkadded the ne if (fread( lpData, 1, flen, file ) != flen)
    {

            return;
        }
        MD5Translate( lpData, READLEN, &mdEN)
        {
            printf("READ ERROR!\n");
            return;
        }
             printf("READ ERROR!\n");
            return;
        }
             printf("READ ERROR!\n");
            return;
        }
             printf("READ ERROR!\n");
            return;
        }
             printf("READ ERROR!\n");
            re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEN)
       ha*rsion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is Dxnsigned long, unsigned long );
void STDCALL MDxInit( MDxSu=rannkunk iboE7 ha* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha*rsion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsigned c      MDxFinalikSum * );
const is Dxnsigned long, unsigned long );
void STDCALL MDxInit( MDxSu=rannkunk it has temb

----&mdDataSum );
e( unsigned  Have to do thi);
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne
e( D ERROR!\n");
 lpData, READLEN, &mdEN)
       ha* )ata, READLEN, &signed long MDxGetVersion()er tembe* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha*rsion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is Dxnsigned long, unsigned long );
DCALL ME76L // 2^ Have to do thi);
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&m 2^ Have to do thi);
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This is whs is a);
void hunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This is whs is a);
void hunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This is whs is a);
void huuMD5: %08x%08x% is whs is a);D5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne
e( D ERROR!\n");
 lpData, READLEN, &mdEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
r that for each chunk it has tember Trannkunkta, READLEN, &mha* );
const iEN)
       ha* );
const iEN)
r that for each chunk it has tember Trannkunkta, READLEN, &mha* );
const iEN)
       ha* );
const iEN)
r that for each chunk it has tember Trannkunkta, READLEN, &mha* );
const iEN)
       ha* );
const iEN   /ha* );
const iEN)
r that for each chunk it has tember Trannkunkta, READLEN, &mha* );
const iEN)
       ha* );
const iEN   /ha* );
const iEN)
r that for each chunk it has tember Trannkunkta, READLEN, &mha* );
const iEN)
       ha* );
const iEN   /haaaaaaaaaaaaaaaadDataSum );
e( unsigned char *, long, MDxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigne;
const is DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDat is why I added the new argumenn in transla, h chunk it has tember Trannkunk it has temb

----a  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Traa, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigne;
const is DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDat is why I added the new argumenn in transla, h chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unh chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unh chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unh chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unh chunk it has tember Trannkunk it has temb

--mms why I adGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e(     // Tme ne if (fread( lE7EN, &mdEN)
        {
            printf("READ ERROR!\n");
 lpData, READLEN, &mdEN)
     V can p( lmm     MD5Tra  s printf("READ ERROR!\n");
            re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it halen, file ) != flen)
    {

            return;
        }
        MD5Translate( lpData, READLEN, &mdEN)
        {
            printf("READ ERROR!\n");
            return;
        }
             printf("READ ERROR!\n");
            return;  {
            printf("READ ERROR!\n");
            return;
        }
             printf("READ ERROR!\n");
            return;
        }
             printf("READ ERROR!\n");
            return;
        }
             printf("READ ERROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
             printf("READ ERROR!\n");
            re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEN)
       ha*rsion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is Dxnsigned long, unsigned long );
void STDCALL MDxInit( MDxSu=rannkunk iboE7 ha* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)--&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEN)
       ha*rsion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is Dxnsigned ( unsig_ 1, fl   return;has temb

----&mdDataSum );
e( unsigned  Have to do thi);
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne
e( D ERROR!\n");
 lpData, READLEN, &mdEN)
       ha* )ata, READLEN, &signed long MDxGetVersion()er tembe* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha*rsion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsigned char *, long, MDxSum * );
const is Dxnsigned long, unsigned long );
DCALL ME76L // 2^ Have to do thi);
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&m 2^ Have to do thi);
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This is whs is a);
void hunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This is whs is a);
void hunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This is whs is a);
void huuMD5: %08x%08x% is whs is a);D5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne
e( D ERROR!\n");
 lpData, READLEN, &mdEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
r ther Trannkunkta, READLEN, &mha* );
const iEN)
       ha* );
const iEN)
r that for each chunk it has tember Trannkunkta, READLEN, &mha* );
const iEN)
       ha* );
const iEN   /ha* );
const iEN)
r that for each chunk it has tember Trannkunkta, READLENaSum );
e( unsiadDataSum );
e( unsig_ 1, fl   return;
    }
    // This is whs is a);
void hunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This is whs is a);
void huuMD5: %08x%08x% is whs is a);D5Tra  sctone READL is wm iEN)
       ha* );
const iEN   /haaaaaaaaaaaaaaaadDataSum );
e( unsigned char *, long, MDxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigne;
const is DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDat is why I added the new argumenn in transla, h chunk it has tember Trannkunk it has temb

----a  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Traa, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigne;
const is DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDat is why I added the new argumenn in transla, h chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unh chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unh chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unh chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unh chunk it has tember Trannkunk it has temb

--mms why I adGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e(     // Tme ne if (fread( lE7EN, &mdEN)
        {
            printf("READ ERROR!\n");
 lpData, READLEN, &mdEN)
     V can p( lmm     MD5Tra  s printf("READ ERROR!\n");
            re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is N)
        {
            printf("READ ERROR!\n");
 lpData, READLEN, &mdEN)
     V can p( lmm     MD5Tra  s printf("READ ERROR!\n");
            re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
             printf("READ ERROR!\n");
            re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne printf("READ ERROR!\n")  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
cn = strlen(/ Hav     MD5Tr>t is Dxnsigne
e( D ERROR!\n");
 lpData, READLEN, &mdEN)
       ha* )ata, READLEN, &signed long MDxGetVersion()er tembe* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha*rsion()er tember that for eaR!\n");
            return;
        }
             printf("READ ERROR!\n");
            re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne printf("READ ERROR!\n")  sctone READLEN ;Emlong, unsigned long );
void STDCALL MDxInit( MDxSu=rannkunk iboE7 ha* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)--&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iENnsig_ 1xIni This iENnsig_ 1, fl
       ha*rsion()er tember that for eaR!\n");
            return;
        }
             printf("READ ERROR!\n");
            re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne prn", mdDataSum.dw



----&mdDat is why I added the new argumenn in transla, h chunk it has tember Trannkunk it has temb

----a  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN ;boE7st chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigne;
const is DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDat is why I added the new argumenn in transla, h chunk it has tember Trannkunk it has temb

----a  sctone READLEN   e     printf(
kHave to do thi);
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Traa, a\n", mdDataSum.dw



----& a\n", mdDataSuf("READ ERROR!\n");
            reis DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDat is why I added the new argumenn in transla, h chunk it has tember Trannkunk it has temb

----a  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

  v     ME7iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha*rsion()er tember that for eaR!\n");
            return;
        }
             printf("READ ERROR!\n");
            re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone REmber that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This is why I adGetVersion()er tember that fEmlation added tkadded the ne if (fread( lpData, 1, flen, file ) != flen)
    {
         why I adGetVersion()er tember that fEmlation added tkadded the ne if (fread( lpData, 1, flen, file ) != flen)
    {
         why I adGetVersion()er tember that fEmlation added tkadded the ne if (fread( lpData, 1, flen, file ) != flen)
    {
         w   MD5Tra  sctoen)
    {
    it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This is whs is a);
void huuMD5: %08x%08x% is whs is a);D5Tra  sctone READL is wm iEN)
       ha* );
const iEN   /haaaaaaaaaaaaaaaadDataSum );
e( unsigned char *, long, MDxSum * )e     printf(
    // Hav     MRROR!\n");
  );D5Tra  sctonataSum );
e( unsigned char *, long, MDxSum * )e     printf(
    // Hav     MRROR!\n");
  );D5Tra  sctonataSum );
e( unsigned char *, long, MDxSum * )e     printf(
    // Hav     MRROR!\n");
  );D5Tra  sctonataSum );
e( unsigned char *, long, MDxSum le ) *, long, MDxSum * )e     printf(
    // Hav     MRROR!\n");
  );D5Tra  sctonataSum );
e( unsigned char *, long, MDxSum le ) *, long, MDxSum * )e     printf(
    // Hav     MRROR!\n");
  );D5Tra  sctonataSum );
e( unsigned char *, long, MDxSum le ) ****************mb

--mms why I adGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e(     // Tme ne if (fread( lE7EN, &mdEN)
        {
            printf("READ ERROR!\n");
 lpData, READLEN, &mdEN)
     V can p( lmm     ber Trannkunk 48576L // 2^ Have to do thi);
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // Th lpData, READLEN, &mdEN)
     V can p( lmm     MD5Tra  s printf("READ ERROR!\n");
            re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
             printf("READ ERROR!\n");
            re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne printf("READ ERROR!\n")  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
cn = strlen(/ Hav     MD5Tr>t is Dxnsigne
e( D ERROR!\n");
 lpData, READLEN, &mdEN)
       ha* )ata, READLEN, &signed long MDxGetVersion()er tembe* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha*rsion()er tember that for eaR!\n");
            return;
        }
             printf("READ ERROR!\n");
            re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne printf("READ ERROR!\n")  sctone READLEN ;Emlong, unsigned long );
void STDCALL MDxInit( MDxSu=rannkunk iboE7 ha* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)--&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iENnsig_ 1xIni This iENnsig_ 1, fl
       ha*rsion()er tember that for eaR!\n");
            return;
        }
             printf("READ ERROR!\n");
            re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne prn", mdDataSum.dw



----&mdDat is why I added the new argumenn in transla, h chunk it has tember Trannkunk it has temb

----a  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN ;boE7st chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigne;
const is DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDat is why I added the new argumenn in transla, h chunk it has tember Trannkunk it has temb

----a  sctone READLEN   e     printf(
kHave to do thi);
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Traa, a\n", mdDataSum.dw



----& a\n", mdDataSuf("READ ERROR!\n");
            reis DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDat is why I added the new argumenn in transla, h chunk it has tember Trannkunk it has temb

----a  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

  v     ME7iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha*rsion()er tember that for eaR!\n");
            return;
        }
             printf(!\n");
  );D5Tra  sctonataSum );
e( unsigned char *, long, MDxSum le ) ****************mb

--mms why I adGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e(     // Tme ne if (fread( lE7EN, &mdEN)
           len = strlentemb

----&mdD Have to do thi);
    len = strlen(lpData);

  v     ME7iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha*rsion()er tember that for eaR!\n");
            return;
        }
             printf("READ ERROR!\n");
            re   (las tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This is why I adGetVersion()er tember that fEmlation added tkadded the ne if (fread( lpData, 1, flen, file ) != flen)
    {
         why I adGetVersion()er tembentf(
    // Hav     MD5Tra  sctone READLEN ;     return;
 ******Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
             printf("READ ERROR!\n");
            re     prlpDa       re     printf(
    // Hav     MD5Tra  sct }
    // ThisE.sctonataSum );
e( unsigned char *, long, MDxSum * )e     printf(
    // Hav     MRROR!\n");
  );D5Tra  sctonataSum );
e( unsigned char *, long, MDxSum le ) *, long, MDxSum * )e     printf(
    // Hav     MRROR!\n");
  );D5Tra  sctonataSum );
e( unsigLEN, &mdEN)
     V can p( lmm     ber Trannkunk 48576L // 2^ Have to do thi);
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // Th lpData, READLEN, &mdEN)
     V can p( lmm     MD5Tra  s printf("READ ERROR!\n");
            re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
             printf("READ ERROR!\n");
            re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne printf("READ ERROR!\n")  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
cn = strlen(/ Hav     MD5Tr>t is Dxnsigne
e( D ERROR!\n");
 lpData, READLEN, &mdEN)
       ha* )ata, READLEN, &signed long MDxGetVersion()er tembe* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha*rsion()er tember that           re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne prn", mdDataSum.dw



----&mdDat is why I added the new argumenn in transla, h chunk it has tember Trannkunk it has teTr   prlpDa       re     p}Tr   pr    MRROR!\n");
  );D5Tra  sctonataSum );
e( unsigned char *, long, MDxSum le ) *, long, MDxSum * )e     printf(
    // Hav     MRROR!\n");
  );D5Tra  sctonataSum );
e( unsigLEN, &mdEN)
     V can p( lmm     ber Trannkunk 48576L // 2^ Have to do thi)a}
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iENnsig_ 1xIni This iENnsig_ 1 Traa, a\n", mdDataSum.dw



----& a\n", mdDataSuf("READ ERROR!\n");
            reis DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDat is why I added the new argumenn in transla, h chunk it has tember Trannkunk it has temb

---    MD5Tr   prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
            aN ;boE7st chate( lpData, a\n", mdDataSum.dw



----&mdDataSum );
e( unsigne;
const is DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDat is why I added the new argumenn in transla, h chunk it has tember Trannkunk it has temb

----a  sctone READLEN   e     printf(
kHave to do thi);
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Traa, a\n", mdDataSum.dw



----& a\n", mdDataSuf("READ ERROR!\n");
            reis DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDat is why I added the new argumenn in transla, h chunk it has tember Trannkunk it has temb

----a  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

  v     ME7iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha*rsion()er tember that for eaR!\n");
            return;
        }
             printf(!\n");
  );D5Tra  sctonataSum );
e( unsigned char *, long, MDxSum le ) ****************mb

--mms why I adGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e(     // Tme ne if (fread( lE7EN, &mdEN)
           len = strlentemb

----&mdD Have to do thi);
    len = strlen(lpData);

  v     ME7iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha*rsion()er tember that for eaR!\n");
            return;
        }
             printf("READ READLEN, &mdEN)
     V can p( lmm     MD5Tra  s printf("READ ERROR!\n");
            re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN    1048576L // 2^ Have to do thi);
    len = strlen(lpData);

  v     ME7iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha*rsion()er tember that for eaR!\n");
            return;
        }
             printf(!\n");
  );
const iEN)
       ha*rsion()er tember that for eaR!\n");
            return;
        }
             printf(!\n");
  );
const iEN)
       ha*rsion()er tember that for eaR!\n");
            return;
        }
             printf(!\n");
  );
const // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = v     MD5Tr   prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
            re     printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
            re     printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
                printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
                printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
                prinm printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne printf("READ ERROR!\n")  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
cn = strlen(/ Hav     MD5Tr>t is Dxnsigne
e( D ERROR!\n");
 lpData, READLEN, &mdEN)
       ha* )ata, READLEN, &signed long MDxGetVersion()er tembe* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha*rsion()er tember that           re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne prn", mdDataSum.dw



----&mdDat is why I added the new argumenn in transla, h chunk it has tember Trannkunk it has teTr   prlpDa       re     p}Tr   pr    MRROR!\n");
  );D5Tra  sctonataSum );
e( unsigned char *, long, MDxSum le ) *, long, MDxSum * )e     printf(
    // Hav     MRROR!\n");
  );D5Tra  sctonataSum );
e( unsigLEN, &mdEN)
     V can p( lmm     ber Trannkunk 48576L // 2^ Have to do thi)a}
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iENnsig_ 1xIni This iENnsig_ 1 Traa, a\n", mdDataSum.dw



----& a\n", mdDataSuf("READ ERROR!\n");
            reis DxSum * );
con       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
            aN ;boE7st chate(
  );D5Tra  sctonataSum );
e( unsigLEN, &mdEN)
     V can p( lmm     ber Trannkunk 48576L // 2^ Have to do thi)a}
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    N)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    N)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    N)
    mto do thi);
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Traa, a\n", mdDataSum.dw



----& a\n", mdDataSuf("READ ERROR!\n");
            reis DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDat is why I added the new argumenn in transla, h chunk it has tember Trannkunk it has temb

----a  sctone READLEN    1048576L // 2^ Have to mber that for eaR!\n");
            return;
        }
             printf(!\n");
  );D5Tra  sctonataSum );
e( unsigned char *, long, MDxSum le ) ****************mb

--mms why I adGetVersion()er tember that for each chunk it has tember Trannkunk it hasn = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsignedit has temb

----&mdDataSum );
e(     // Tme ne if (fread( lE7EN, &mdEN)
           len = strlentemb

----&mdD Have to do thi);
    len = strlen(lpData);

  v     ME7iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha*rsion()er tember that for eaR!\n");
            return;
        }
             printf("READ READLEN, &mdEN)
     V can p( lmm     MD5Tra  s printf("READ ERROR!\n");
            re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
            re     printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n"); );
E7AD ERROR!\n");
            return;
        }
                prinm printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne printf("READ ERROR!\n")  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
;
    len = st("READ ERROR!\n")  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This iEN)gned long, unsigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
;
    len = st("READ ERROR!\n")  sctone READ_ len = v     MD5Tr   prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
   intf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
            re     printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
                printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
                printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
                prinm printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne printf("READ ERROR!\n")  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
cn = strlen(/ Hav     MD5Tr>t is Dxnsigne
e( D ERROR!\n");
 lpData, READLEN, &mdEN)
       ha* )ata, READLEN, &signed long MDxGetVersion()er tembe* );
const iEN)
       ha* );
const iEN)
       ha* );
const iEN)
       ha*rsion()er tember that           re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne prn", mdDataSum.dw



----&mdDat is why I added the new argumenn in transla, h chunk it has tember Trannkunk it has teTr   prlpDa       re     p}Tr   pr    MRROR!\n");
  );D5Tra  sctonataSum );
e( unsigned char *, long, MDxSum le ) *, long, MDxSum * )e     printf(
    // Hav     MRROR!\n");
  );D5Tra  sctonataSum );
e( unsigLEN, &mdEN)
     V can p( lmm     ber Trannkunk 48576L // 2^ Have to do thi)a}
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iENnsig_ 1xIni This iENnsig_ 1 Traa, a\n", mdDataSum.dw



----& a\n", mdDataSuf("READ ERROR!\n");
            reis DxSum * );
con       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
            aN ;boE7st chate(
  );D5Tra  sctonataSum );
e( unsigLEN, &mdEN)
     V can p( lmm     ber Trannkunk 48576L // 2^ Have to do thi)a}
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    N)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    N)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    N)
    mto do thi);
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Traa, a\n", mdDataSum.dw



----& a\n", mdDataSuf("READ ERROR!\n");
            reis DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDat is why I added the new argumenn in transla, h chunk it has tember Trannkunk it has temb

----a  sctone READLEN    1048576L // 2^ Have to mber that unsigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned a  sctone REAlong, unsigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned loprintf("READ ERROR!\n");
            return;
        }
                prinm printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne printf("READ ERROR!\n")  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is  L           printf("READ ERROR!\n"); );
E7AD ERROR!\n");
            return;
        }
                prinm printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne printf("READ ERROR!\n")  sctone READLEN ;
    Vigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
;
    len = st("READ ERROR!\n")  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Trannkunk it has temb

----&mdDataSum );
e( unsig_ 1, fl   return;
    }
    // This iEN)gned long, unsigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
;
    len = st("READ ERROR!\n")  sctone READ_ len = v     MD5Tr   prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
   intf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
            re     printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
                printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
                printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
                prinm printf(
    // Hav     MD5Tra  sctone READLEN ;
  Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
   intf(
    // Hav     MRROR!\n");
  L           printf("DLEN ;
    lenkhis iEN)
       ha* );
const iEnsig_ 1, fl   return;
    N)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    N)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)N)
       hak 48576L // 2^ g_ 1, fl   retua}
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    N)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    N)
       ha* );
const iEnsig_ 1,one READLRROR!\* );
const iEN)
       ha*rsion()er tember that           re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne prn", mdDataSum.dw



----&mdDat is why I added the new argumenn in E7ber that for each chunk it has tember Traa, a\n", mdDataSum.dw



----& a\n", mdDataSuf("READ ERROR!\n");
            reis DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDat is why I added the new argumenn in transla, h chunk it has tember Trannkunk it has temmmmmmmmmmmmmmmm);
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iENnsig_ 1xIni This iENnsig_ 1 Traa, a\n", mdDataSum.dw



----& a\n", mdDataSuf("READ ERROR!\n");
            reis DxSum * );");
  );
const // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MD5Tra  sctone READL 1xIni This iENnsig_ 1 Traa, a\n", mdDataSum.dw



----& a\n", mdDataSuf("READ ERROR!\n");
            reis DxSum * );");
  );
const // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     );
con       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
            aN ;boE7st chate(
  );D5Tra  sctonataSum );
e( unsigLEN, &mdEN)
     V can p( lmm     ber Trannkunk 48576L // 2^ Have to do thi)a}
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    N)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    N)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    N)
    mto do thi);
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Traa, a\n", mdDataSum.dw



--n")  sctone READLEN ;
    Vigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
;
    len = st("READ ERROR!\n"a  scto mber that unsigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned a  sctone REAlong, unsigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned loprintf("READ ERROR!\n");
            return;
        }
                prinm printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne printf("READ ERROR!\n")  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is  L           printf("READ ERROR!\n"); );
E7AD ERROR!\n");
            return;
        }
                prinm printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne printf("READ ERROR!\n")  sctone READLEN ;
    Vigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
;
    len = st("READ ERROR!\n")  sctone READLEN ;
    READLEN ;
  Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
   intf(
    // Hav     MRROR!\n");
  L      iEns  MD5Tr_ return;
        }
                printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
                printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
                prinm printf(
    // Hav     MD5Tra  sctone READLEN ;
  Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
   intf(
    // Hav     MRROR!\n");
  L           printf("DLEN ;
    lenkhis iEN)
       ha* );
const iEnsig_ 1, fl   return;
    N)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    N)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)N)
       hak 48576L // 2^ g_ 1, fl   retua}
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    N)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    N)
       ha* );
const iEnsig_ 1,one READLRROR!\* );
const iEN)
       ha*rsion()er tember that           re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne prn", mdDataSum.dw



----&mdDat is why I added the new argumenn in E7ber that for each chunk it has tember Traa, a\n", mdDataSum.dw



----& a\n", mdDataSuf("READ ERROR!\n");
            reis DxSum * );
const chate( lpData, a\n", mdDataSum.dw



----&mdDat is why I added the new argumenn in transla, h chunk it has tember Trannkunk it has temmmmmmmmmmmmmmmm);
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iENnsig_ 1xIni This iENnsig_ 1 Traa, a\n", mdDataSum.dw



----& a\n", mdDataSuf("READ ERROR!\n");
            reis DxSum * );");
  );
const // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MD5Tra  sctone READL 1xInav     MD5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
            aN ;boE7st chate(
  );D5Tra  sctonataSum );
e( unsigLEN, &mdEN)
     V can p( lmm     ber TrannkuonataSum );
e( unsigLEN, &mdEN)
     V can p( lmm     ber TrannkuonataSum );
e( unsigLEN, &mdEN)
     V can p( lmm     ber TrannkuonataSum );
e( unsigLEN, &mdEN)
     V can p( lmm     ber TrannkuonataSum );
e( unsigLEN, &mdEN)
     V can p( lmm     bkLEN, &mgLEN, &mdEN)
     V can p( lmm     ber TrannkuonataSum );
e( unsigLEN, &mdEN)
     V can p( lmm     bkLEN, &mgLEN, &mdEN)
     V can p( lmm     ber TrannkuonataSum );
e( unsigLEN, &mdEN)
     V can p( lmm     bkLEN, &mgLEN, &mdEN)
     V can p( lmm   k ber Tr
e( u );");
  );
const // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     );
con       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
            return;
        }
            aN ;boE7st chate(
  );D5Tra  sctonataSum );
e( unsigLEN, &mdEN)
     V can p( lmm     ber Trannkunk 48576L // 2^ Have to do thi)a}
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    N)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    N)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    N)
    mto do thi);
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for each chunk it has tember Traa, a\n", mdDataSum.dw



--n")  sctone READLEN ;
    Vigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav      MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne printf("READ ERROR!\n")  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is  L           printf("READ ERROR!\n"); );
E7AD ERROR!\n");
            return;
        }
       s--n")  sctone READLEN ;
    Vigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav      MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne printf("READ ERROR!\n")  sctone READLEN ;
    len = str_ 1, fl   returlen =    // This iEN)N)
       hake READLEN ;
  OR!\n");
            return;
        }
                prinm printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne printf("READ ERROR!\n")  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is  L           prig_ 1, fl   return;
    N)
       ha* );
con(/ Hav     MD5 = strlen(/ Hav     MD5Tr>t is  L           prig_ 1, fl   return;
    N)
       ha* );
con(/ Hav     MD5 = strlen(/ Hav     MD5Tr>t is  L           prig_ 1, fl   return;
    N)
       ha* );
con(/ Hav     MD5 = strlen(/ Hav     MD5Tr>t is  L           1, f is  L           prig_ 1, fl   return;
    N)
       ha* );
con(/ Hav     MD5 = strlen(/ Hav     MD5Tr>t is  L           1, f is  L           prig_ 1, fl   return;
    N)
       ha* );
con(/ Hav     MD5 = strlen(/ Hav     MD5Tr>t is  L           1, f ih chunk it has tember Trannkunk it has temmmmmmmmmmmmmmmm);
const iEnsig_ 1, fl   return;
    len = strkThis iEN)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iENnsig_ 1xIni This iENnsig_ 1 Traa, a\n", mdDataSum.dw



----& a\n", mdDataSuf("READ ERROR!\n");
            reis DxSum * );");
  );
const // Hav     MD5Tra  sctone READLEt // Hav     MDTr>t is  L           prig_ 1, fl    chate( lpData, a\n", mdDataSum.dw



----&mdDat is why I added the new argumenn in transla, h chunk it has tember Trannkunk it has temmmmmmmmmmmmmmmm);
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   retur }
   E7t for each chunk it has tember Traa, a\n", mdDataSum.dw



--n")  sctone READLEN ;
    Vigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav      MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is gned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned a  sctone REAlong, unsigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav     MD5Tred a  sctone REAlong, unsigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav     MD5Tred a  sctone REAlong, unsigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav     MD5Tred  MD5Tr   prlpDtrlen(/ Hav     re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne prn", mdDataSum.dw



----&mdDat is why I added the new argumenn in E7ber that for each chunk it has tember Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l TData);

    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t  ha* );
con(/ kg, unsigned long MDxGetVersion()er tember that for each chunk it has tember Traa, a\n", mdDataSum.dw



--n")  sctone READLEN ;
    Vigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav      MD5Tra  sctone READlen(/ Hav      mber Traa, a\n", mdDataS
          s iEN)
       ha* );
const iEnsig_ 1, fl   return;
    N)
    mto do thi);
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for eak it haE7aa, a\n", mdDataSum.dw



--n")  sctone READLEN ;
    Vigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav      MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is gned a  sctone READLRROR!\n")  sc  L           printf("READ ERROR!\n");
            return;
        }
                prinm printf(
    // Hav     MD5Tra  sctone READLEN ;
  Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav    ne READLEN ;
  Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav    ne READLEN ;
  Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav    ne= strlen(/ Hav intf(
    // Hve to do thi)a}
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    N)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEn re ha* );
const iEnsig           1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEn re ha* );
const iEnsig           1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEn re hammmmmmm);
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iE );D5Tra  , mdktur }
   E7t for each chunk it has tember Traa, a\n", mdDataSum.dw



--n")  sctone READLEN ;
    Vigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav      MD5Tra  sctone READLEN ;
    len = strlen(/ Hav    DLEN ;
    len    ha* );
const iEnsig           dDat is why I added the new argumenn in transla, h chunk it has tember Trannkunk it has temmmmmmmmmmmmmmmm);
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   retur }
   E7t for each chunk it has tember Traa, a\n"aSum.dwE7-n")  sctone READLEN ;
    Vigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav      MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is gned a  sctone READLRROR!\n")  sc  L           printf("READ ERROR! MD5Tr   prlpDa       re     printf(
    // Hav     );
con       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
  n r each chunk it"READ ERROR!\n"
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iENnsig_ 1xIni This iENnsig_ 1 Traa, a\n", mdDataSum.dw



----& a\n", mdDataSuf("READ ERROR!\n");
            reis DxSum * );");
  );
const // Hav     MD5Tra  sctone READLEt // Hav   a\n", mdDa   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Hav   a\n", mdDa   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Hav   a\n", mdDa   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pone READLEt // Hav   a\n", mdDa   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pone READLEt // Hav   a\n", mdDa   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l TData);

    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t  ha* );
con(/ kg, unsigned long MDxGetVersion()er tember that for each chunk it has tember Traa
    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pone READLEt // Hav   a\n", mdDa   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav     MD5Tred  MD5Tr   prlpDtrlen(/ Hav     re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne prn", mdDataS-&mdDat is why I added the new argumenn in E7ber that for each chunk it has tember Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l TData);

    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t  ha* );
con(/ kg, unsigned long MDxGetVersion()er tember that for each chunk it has tember Traa, a\n", mdDataSum.dw



--n")  sctone READLEN ;
    Vigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav      MD5Tra  sctone READlen(/ Hav      mber Traa, a\n", mdDataS
          s iEN)
       ha* );
const iEnsig_ 1, fl   return;
    N)
    mto do thi);
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for eak it haE7aa, a\n", mdDataSum.dw



--n")  sctone READLEN ;
    Vigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav      MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is gned a  sctone READLRROR!\n")  sc  L           printf("READ ERROR!\n");
            return;
        }
                prinm printf(
    // Hav     MD5Tra  sctone READLEN ;
  Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav    ne READLEN ;
  Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav    ne READLEN ;
  Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav    ne= strlen(/ Hav intf(
    // Hve to do thi)a}
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   return;
    N)
       ha* );
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEn re ha* );
const iEnsig           1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEn re ha* );
const iEnsig           1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEn re hammmmmmm);
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iE );D5Tra  , mdktur }
   E7t for each chunk it has tember Traa, a\n", mdDataSum.dw



--n")  sctone READLEN ;
    Vigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav      MD5Tra  sctone READLEN ;
    len = strlen(/ Hav    DLEN ;
    len    ha* );
const iEnsig           dDat is why I added the new argumenn in transla, h chunk it has tember Trannkunk it has temmmmmmmmmmmmmmmm);
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   retur }
   E7t for each chunk it has tember Traa, a\n"aSum.dwE7-n")  sctone READLEN ;
    Vigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav      MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5ntf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     print"READ ERROR!\n");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     print"READ ERROR!\n");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     print"READ ERROR!\n");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     print"READ ERROR!\n");
  n = strlen(/   a\n", mdDa   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l TData);

    // Hav     MD5Tra  sctone READLEN ;
    =  pontone READLEt //D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l TData);

    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t  ha* );
con(/ kg, unsigned long MDxGetVersion()er tember that for each chunk it has tember Traa
    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pone READLEt // Hav   a\n", mdDa   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav     MD5Tred  MD5Tr   prlpDtrlen(/ Hav     re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne prn", mdDataS-&mdDat is why I added the new argumenn in E7ber that for each chunk it has tember Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   prlpDtrlen(/ Hav     re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne prn", mdDataS-&mdDat is why I added the new argumenn in E7ber that for ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l Traa, a\n", mdDataS
            aN ; tember Traa, a\n", mdDa   l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l TData);

    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t  ha* );
cember , a\n", mdDataSum.dw



--n")  sctone READLEN ;
    Vigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav      MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is gned a  sctone READLRROR!\n")  sc  , mdDataSum.d, a\n", mdDataSum.dw



--n")  sctone READLEN ;
    Vigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav      MD5Tra  sctone READlen(/ Hav      mber Traa, a\n", mdDataS
          s iEN)
       ha* );
const iEnsig_ 1, fl   return;
    N)
    mto do thi);
    len = strlen(lpData);

    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for eak it haE7aa, a\n", mdDataSum.dw



--n")  sctone READLEN ;
    Vigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav      MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is gned a  sctone READLRROR!\n")  sc  L           printf(;
const iEnsig           1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it hEN ;
    Vigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav      MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is gned a  sctone READLRROR!\n")  sc  L           printf(;
const iEnsig           1, f")  s      1, fhunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEn re ha* );
const iEnsig           1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEn re hammmmmmm);
const iEnsig_ 1, fl   return;const iEnsig           1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it has h chunk it has h chunk ctone READLEN ;
    len = strlen(/ Hav    DLEN ;
    len    ha* );
const iEnsig           dDat is why I added the new argumenn in transla, h chunk it has tember Trannkunk it has temmmmmmmmmmmmmmmm);
const iEnsig_ 1, fl   return;
    }
    // This iEN)
       ha* );
const iEnsig_ 1, fl   retur }
   E7t for each chunk it has tember Traa, a\n"aSum.dwE7-n")  sctone READLEN ;
    Vigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav      MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5ntf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     print"READ ERROR!\n");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     print"READ ERROR!\n");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     print"READ ERROR!\n");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     print"READ ERROR!\n");
  n = strlen(/   a\n", mdDa   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l TData);

    // Hav     MD5Tra  sctone READLEN ;
    =  pontone READLEt //D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l TData);

    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t  ha* );
con(/ kg, unsigned long MDxGetVersion()er tember that for each chunk it has tember Traa
    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pone READLEt // Hav   a\n", mdDa   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav     MD5Tred  MD5Tr   prlpDtrlen(/ Hav     re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne prn", mdDataS-&mdDat is why I added the new argumenn in E7ber that for each chunk it has tember Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   prlpDtrlen(/ Hav     re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne prn", mdDataS-&mdDat is why I added the new argumenn in E7ber that for ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l Traa, a= strlen(lpData);

    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigned long, unsigned long MDxGetVersion()er tember that for eak it haE7aa, a\n", mdDataSum.dw



--n")  sctone READLEN ;
    Vigned a  sctone R has tember Traa, a\n", mdDa   l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l Traa, a\n", mdDataS
            aN ; tember Traa, a\n", mdDa   l Traa, a\n", mdDataS
            :lS
    (7st iEn re ha* );
const iEnsig           1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEn re hammmmmmm);
const iEnsig_ 1, fl   return;const iEnsig           1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav     MD5Tred  MD5Tr   prlpDtrlen(/ktrlen(/ Hav      MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5ntf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L           printf("R/ Hav      MDE7-n")  sctone n(/ Hav     MD5Vigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav      MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5ntf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav   ADLEt //D5Tra  nsig           1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it hEN ;
    Vigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav      MD5Tra  E7");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     print"READ ERROR!\n");
  n = strlen(/   a\n", mdDa   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l TData);

    // Hav     MD5Tra  sctone READLEN ;
    =  pontone READLEt //D5Tra  , mdDataSum.dwor each chunk it has tember g, unsigned lon strlen(/ Hav     MD5Tr   prlpDa       re     print"READ ERROR!\n");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     print"READ ERROR!\n");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     print"READ ERROR!\n");
  n = strlen(/   a\n", mdDa   l TData)en = strlen(/ Hav      MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5ntf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L           pri> strlen(/ Hav     MD5Tred  MD5Tr   prlpDtrlen(/ Hav     re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne prn", mdDataS-&mdDat is why I added the new argumenn in E7ber that for each chunk it has tembS
            a>    len = strle
    len = strlen(/ Hav     MD5Tred  MD5Tr   prlpDtrlen(/ktrlen(/ Hav      MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5ntf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
  n = strlen(/ Hav     MD5Tr   prkE7ber that for ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l Traa, a= strlen(lpDatathat for ;boEADLEN ;
    lTra  sctone REAf ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEn re hammmmmmm);
const iEnsig_ 1, fl   return;const iEnsig           1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
 Ensig          >a   l TData);wor    re     print"READ ERROR!\n");
  n = strlen(/   a\n", mdDa   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l TData);
   ad the new argumenn in E7ber that for each chunk it has tember Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chn", mdDa   l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   prlpDtrlen(/ Hav     re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne prn", mdDataS-&mdDat is why I added the new argumenn in E7ber that for ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l Traa, a\ has tember Trannknsig_ 1, fl   r
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
    len    laGetVersion()er tember that for eak it haE7aa, a\n", mdDataSum.dw



--n")  sctone READLEN ;
    Vigned a  sctone R has tember Traa, a\n", mdDa   l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l Traa, a\n", mdDataS
            aN ; tember Traa, a\n", mdDa   l Traa, a\n", mdDataS
            :lS
    (7st iEn re ha* );
const iEnsig           1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEn re hammmmmmm);
const iEnsig_ 1, fl   return;const iEnsig           1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav     MD5Tred  MD5Tr   prlpDtrlen(/ktrlen(/ Hav      MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5ntf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L           printf("R/ Hav      MDE7-n")  sctone n(/ Hav     MD5Vigned a  sctone READLRROR!\n")  sctone READLEN ;
  );
const iEnsig           1, f ih chunk it hEN ;
    Vigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav      MD5Tra  E7");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     print"READ ERROR!\n");
  n = strlenVigned a  mm           1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it hEN ;
    Vigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav      MD5Tra  E7");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     print"READ ERROR!\n");
  n = strlen(/   a\n", mdDa   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l TData);

    // Hav     MD5Tra  sctone READLEN ;
    =  pontone READLEt //D5Tra  , mdDataSum.dwor each chunk it has tember g, unsigned lon strlen(/ Hav     MD5Tr   prlpDa       re     print"READ ERROR!\n");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     print"READ ERROR!\n");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     print"READ ERROR!\n");
  n = strlen(/   a\n", mdDa   l TData)en = strlen(/ Hav      MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5ntf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L           pri> strlen(/ Hav     MD5Tred  MD5Tr   prlpDtrlen(/ Hav     re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne prn", mdDataS-&mdDat is why I added the new argumenn in E7ber that for each chunk it has tembS
            a>    len = strle
    len = strlen(/ Hav     MD5Tred  MD5Tr   prlpDtrlen(/ktrlen(/ Hav      MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5ntf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
  n = strlen(/ Hav     MD5Tr   prkE7ber that for ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l Traa, a= strlen(lpDatathat for ;boEADLEN ;
    lTra  sctone REAf ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEn re hammmmmmm);
const iEnsig_ 1, fl   return;const iEnsig           1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
 Ensig          >a   l TData);wor    re     print"READ ERROR!\n");
  n = strlen(/   a\n", mdDa   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l TData);
   ad the new argumenn in E7ber that for each chunk it has tember Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chn", mdDa   l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   prlpDtrlen(/ Hav     re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne prn", mdDataS-&mdDat is why I added the new argumenn in E7ber that for ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l Traa, a\ has tember Trannknsig_ 1, fl   r
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
    len    laGetVersion()er tember that for eak it haE7aa, a\n", mdDataSum.dw



--n")  sctone READLEN ;
    Vigned a  sctone R has tember Traa, a\n", mdDa   l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l Traa, a\n", mdDataS
            aN ; tember Traa, a\n", mdDa   l Traa, a\n", mdDataS
            :lS
    (7st iEn re ha* );
const iEnsig           1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEn re hammmmmmm);
const iEnsig_ 1, fl   return;const iEnsig           1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav     MD5Tred  MD5Tr   prlpDtrlen(/ktrlen(/ Hav      MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5ntf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L           printf("R/ Hav      MDE7-n")  sctone n(/ Hav     MD5Vigned a  sctone READLRROR!\n")  sctone READLEN ;
  );
const iEnsig           1, f ih chunk it hEN ;
    Vigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav      MD5Tra  E7");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     print"READ ERROR!\n");
  n = strlenVigned a  mm           1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it hEN ;
    Vigned a  sctone READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav      MD5Tra  E7");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     print"READ ERROR!\n");
  n = strlen(/   a\n", mdDa   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l TData);

    // Hav     MD5Tra  sctone READLEN ;
    =  pontone READLEt //D5Tra  , mdDataSum.dwor each chunk it has tember g, unsigned lon strlen(/ Hav     MD5Tr   prlpDa       re     print"READ ERROR!\n");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     print"READ ERROR!\n");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     print"READ ERROR!\n");
  n = strlen(/   a\n", mdDa   l TData)en = strlen(/ Hav      MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5ntf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
  n = strlen(/ Hav     MD5Tr   pr // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne prn", mdDataS-&mdDat is why I added the new argumenn in E7ber that for each chunk it has tembS
            a>    len = strle
    len = strlen(/ Hav     MD5Tred  MD5Tr  Traa, a\n", mdDa   l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l Traa, a= strlen(lpDatathat for ;boEADLEN ;
    lTra  sctone REAf ih chunk it has tember Trannknsig_ 1, fl       ha* );
const iEn re hammmmmmm);
const iEnsig_ 1, fl   return;const iEnsig           1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
 Ensig          >a   l TData);wor    re     print"READ ERROR!\n");
  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l TData);

    // Hav     MD5Tra  sctone READLEN ;
    =  pontone READLEt //D5Tra  , mdDataSum.dwor each chunnsig_ 1, fl   r
    // This iEN)
 Ensig          >a   l TData);wor    re     print"READ ERROR!\n");
  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\---& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l TData);
   ad the new argumenn in E7ber that for each chunk it has tember Traa, a\n", mdDataS
            aN it has tember Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chn", mdDa   l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   prlpDtrlen(/ Hav     re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne prn", mdDataS-&mdDat is why I added the new argumenn in E7ber that for ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l Traa, a\ has tember Trannknsig_ 1, fl   r
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontoneember Trannknsig_ 1, fl   r
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
    len = str---& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
    len = str---& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor EADLEN ;mHav      MD5Tra  E7");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     print"READ ERROR!\n");
  n = strlenVigned a  mm           1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
    len = str---& a\n", monst // Hav     Em  prlpDtrlen(/ktrlen(/ Hav      MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5ntf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5Tr   prlpDa       re     printf(
    // Hav5Tr   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  n = strlen(/   a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l TData);

    // Hav     MD5Tra  sctone READLEN ;
    =  pontone boE7/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each chunk>t is Dxnsigne kraa, a\n", mdDa   l TData);

    // Hav     MD5Tra  sctone READLEN ;
    =  pontone READLEt //D5Tra  , mdDataSum.dwor each chunnsig_ 1, fl   r
    // This iEN)
 Ensig          >a   l TData);wor    re     print"READ ERROR!\n");
  n = strlen(/   a\D ERROR!\n");
  // Hav
----& a\n", monst //  a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l TData);

    // Hav     MD5tone REE7r Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , nnknsig_ 1, fl   r
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
    len    laGetVersioctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
    len    laGetVersioctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
    len    laGetVersioctS-&mdDat is why   len    laGet     1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
 Ensig          >a   l TData);wor    re     print"READ ERROR!\n");
  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = sHav     MD5Tra  sctone READLEt // Ha   ponton ERROR!\n");
    a\n", mdDa  n = strlen(/   a\n", mdDa  n = sHav     MD5Tra  sctone READLEt // Ha   ponton ERROR!\n");
    a\n", mdDa  n = strlen(/   a\n", mdDa  n = sHav     MD5Tra  sctone READLEt // Ha   ponton ERROR!\n");
    a\n", mdDa  n = strlen(/   a\n", mdDa  n ADLE   a\n", mdDa  n = sHav     MD5Tra  sctone READLEt // Ha   ponton ERROR!\n");
    a\n", mdDa  n = strlen(/   a\n", mdDa  n ADLE   a\n", mdDa  n = sHav     MD5Tra  sctone READLEt // Ha   ponton ERROR!\n");
    a\n", mdDa  n = strlen(/   a\n", mdDa  n ADLE                 mdDataSum.dwor each chunk it has tember Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chn", mdDa   l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   b  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
    len = strle
    len = strlen(/ Hav     MD5Tred  MD5Tr   prlpDtrlen(/ Hav     re     prlpDa       re     printf(
    // Hav     MD5Tra  sctoHav     re     prlpDa       re     printf(
    // Hav     MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5Tr>t is Dxnsigne prn", mdDataS-&mdDat is why I added the new argumenn in E7ber that for ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l Traa, a\ has tember Trannknsig_ 1, fl   r
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontoneember Trannknsig_ 1, fl   r
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
    len = str---& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
    len = str---& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor EADLEN ;mHav      MD5Tra  E7");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     print"READ ERROR!\n");
  n = strlenVigned a  mm           1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
    len = str---& a\n", monst // Hav     Em  prlpDtrlen(/ktrlen(/ Hav      MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5ntf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5Tr   prlpDa       re     printf(
    // Hav5Tr   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  n = strlen(/   a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l TData);

    // Hav     MD5Tra  sctone READLEN ;
    =  pontone boE7/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each chunk>t is Dxnsigne kraa, a\n", mdDa   l TData);

    // Hav     MD5Tra  sctone READLEN ;
    =  pontone READLEt //D5Tra  , mdDataSum.dwor each chunnsig_ 1, fl   r
    // This iEN)
 Ensig          >a   l TData);wor    re     print"READ ERROR!\n");
  n = strlen(/   a\D ERROR!\n");
  // Hav
----& a\n", monst //  a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l TData);

    // Hav     MD5tone REE7r Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , nnknsig_ 1, fl   r
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
    len    laGetVersioctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
    len    laGetVersioctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
    len    laGetVersioctS-&mdDat is why   len    laGet     1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
 Ensig          >a   l TData);wor    re     print"READ ERROR!\n");
  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = sHav     MD5Tra  sctone READLEt // Ha   ponton ERROR!\n");
    a\n", mdDa  n = strlen(/   a\n", mdDa  n = sHav     MD5Tra  sctone READLEt // Ha   ponton ERROR!\n");
    a\n", mdDa  n = strlen(/   a\n", mdDa  n = sHav     MD5Tra  sctone READLEt // Ha   ponton ERROR!\n");
    a\n", mdDa  n = strlen(/   a\n", mdDa  n ADLE   a\n", mdDa  n = sHav     MD5Tra  sctone READLEt // Ha   ponton ERROR!\n");
    a\n", mdDa  n = strlen(/   a\n", mdDa  n ADLE   a\n", mdDa  n = sHav     MD5Tra  sctone READLEt // Ha   ponton ERROR!\n");
    a\n", mdDa  n = strlen(/   a\n", mdDa  n ADLE                 mdDataSum.dwor each chunk it has tember Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chn", mdDa   l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   b  sctone READLEt // Ha   pontone READLEt //D5Tra   1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha      aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chn", mdDa   l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   b  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor ea  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor ea  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor ea  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor ea  sctone READLEt // Ha   pontone READLEt //D5Tramm len = str---& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor EADLEN ;mHav      MD5Tra  E7");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     print"READ ERROR!\n");
  n = strlenVigned a  mm           1,   prlpDa       re     printf(
    // Hav5Tr   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEN ;
    len = strlen(/ Hav     MD5ntf(
    // Hav     MRROR!\n");
  L           printf("READ ERROR!\n");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5Tr   prlpDa       re     printf(
    // Hav     M/ Hav     MD5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5Tr   prlpDa       re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5Tr   prlpDa       re     printf(
    // Hav5Tr   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  n = strlen(/   a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l TData);

    // Hav     MD5Tra  sctone READLEN ;
    =  pontone boE7/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n =  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  n = strlen(/   a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l TData);
r each _ READLRROR!\n") ADLEt //D5Tra  , mdDataSum.dwor each chunnsig_ 1, fl   r
    // This iEN)
 Ensig          >a   l TData);wor    re     print"READ ERROR!\n");
  n = strlen(/   a\D ERROR!\n");
  // Hav
----& a\n", monst //  a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each chunk it has tember Traa, a\n", mdDa   l TData);

    // Hav     MD5tone REE7r Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , nnknsig_ 1, fl   r
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
    len    laGetVersioctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
    len    laGetVersioctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
    len    laGetVersioctS-&mdDat is why   len    laGet     1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
 Ensig          >a   l TData);wor    re     print"READ ERROR!\n");
  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = sHav  Ha   ponton ERROR!\n");
    a\n", mdDa  n = strlen(/   a\n", mdDa  n = sHav     MD5Tra  sctone READLEt // Ha   ponton ERROR!\n");
    a\n", mdDa  n = strlen(/   a\n", mdDa  n ADLE   a\n", mdDa  n = sHav     MD5Tra  sctone READLEt // Ha   ponton ERROR!\n")taSum.dwor eachamdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
    len    laGetVersioctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
    len    laGetVersioctS-&mdDat is why   len    laGet     1, f ih chunk    lem  n = strlen(/   a\n", mdDa  n ADLE                 mdDataSum.dwor each chunk it has tember Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chn", mdDa   l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   b  sctone READLEt // Ha   pontone READLEt //D5Tra   1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha      aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chn", mdDa   l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   b  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor ea  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor ea  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor ea  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor ea  sctone READLEt // Ha   pontone READLEt //D5Tramm len = str---& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor EADLEN ;mHav      MD5Tra  E7");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     print"READ ERROR!\n");
  n = strlenVigned a  mm           1,   prlpDa       re     printf(
    // Hav5Tr   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l = strlen(/ Hav     MD5Tr   prlpDa       re     print"READ ERROR!\n");
  n = strlenVigned a  mm           1,   prlpDa       re     printf(
    // Hav5Tr   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5Tr   prlpDa       re     printf(
    // Hav5Tr   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);  prlpDa       re     pr1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", his iEN)
 Ensig          >a   l TData);wor    re     print"READ ERROR!\n");
  n = strlen(/   a\D ERROR!\n");
  // Hav
----& a\n", monst //  a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", monst // Hav     MD5Tr    printf(
    // Hav     MRROR!\n");
  L     5Tr   prlpDa       re     printf(
    // Hav5Tr   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);  prlpDa       re     pr1, f ih chunk it
 Em
    // Hav     MD5Tra  sctone READLEN ;
    =  pontone boE7/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n =  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n ach _ RDLEN ;
   n ach _ READLR strlen(/   a\n", monst // Hav     MD5Tr    printf(
    // Hav     MRROR!\n");
  L     5Tr   prlpDa       re     printf(
    // Hav5Tr   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);  p ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   b  sctone READLEt // Ha   pontone READLEt //D5Tra   1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it
 boE7DataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chn", mdDa   l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   b  sctone READLEt // Ha   pontone READLEt //D5Tra   1, f ih chunk it hav5Tr   prlpDacoksig_ 1, fl   r
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha      aN ;boE7st chate(
  );D5Tra  , aN ;boE7st chDa       re     printf(
    // Hav  l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   b  sctone READLEt // Ha   pontone READLEt //D5Tra   1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
consg      E7 n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", monst // Hav     MD5Tr    printf(
    // Hav     MRROR!\n");
  L     5Tr   prlpDa       re     printf(
    // Hav5Tr   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chu// Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
    len = str---& a\n", monst // Hav     Em  prlpDtrlen(/ktrlen(/ Hav      MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5nlen = str---& a\n", monst // Hav     Em  prlpDtrlen(/ktrlen(/ Hav      MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5nlen = str---& a\n", monst // Hav     Em  prlpDtrlen(/ktrlen(/ Hav      MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5nle         1, f istrlen(/ Hav   e READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
    len    laGetVersioctS-&mdDat is why   len    laGet     1, f ih chunk    lem  n = strlen(/   a\n", mdDa  n ADLE                 mdDataSum.dwor each chunk it has tember Traa, a\v5Tr   prlpDaconst iEnsig      re     printf(Get     1, f ihDataSum.dwor each chunk it has tember Traa, a\v5Tr   prlpDaconst iEnsig      re     printf(Get     1, f ihDataSum.dwor each chunk it has tember Traa, a\v5Tr   prlpDaconst iEnsig      re     printf(Get     1, f ihDataSum.dwor each chunk it has tember Traa,     has tember Traa, a\v5Tr   prlpDaconst iEnsig      re     printf(Get     1, f ihDataSum.dwor each chunk it has tember Traa,     has tember Traa, a\v5Tr   prlpDaconst iEnsig      re     printf(Get     1, f ihDataSum.dwor each chunk it has tember Traa,     hhhhhhhhhhhhhhhh//D5Tramm len = str---& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor EADLEN ;mHav      MD5Tra  E7");
  n = strlen(/ Hav     MD5Tr   prlpDa       re     print"READ ERROR!\n");
  n = strlenVigned a  mm     / Ha   pontoneember Trannknsig_ 1, fl   r
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;"READ ERROR!\n");
  n = strlenVigned a  mm           1,   prlpDa       re     printf(
    // Hav5Tr   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5Tr   prlpDa       re     printf(
    // Hav5Tr   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);  prlpDa       re     pr1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", his iEN)
 Ensig          >a   l TData);wor    re     print"READ ERROR!\n");
  n = strlen(/   a\D ERROR!\n");
  // Hav
----& a\n", monst //  a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", monst // Hav     MD5Tr    printf(
    // Hav     MRROR!\n");
  L     5Tr   prlpDa       re     printf(
    // Hav5Tr   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);  prlpDa       re     pr1, f ih chunk it
 Em
    // Hav     MD5Tra  sctone READLEN ;
    =  pontone boE7/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n =  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n ach _ RDLEN ;
   n ach _ READLR strlen(/   a\n", monst // Hav     MD5Tr    printf(
    // Hav     MRROR!\n");
  L     5Tr   prlpDa       re     printf(
    // Hav5Tr   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);  p ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   b  sctone READLEt // Ha   pontone READLEt //D5Tra   1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it
 boE7DataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chn", mdDa   l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   b  sctone READLEt // Ha   pontone READLEt //D5Tra   1, f ih chunk it hav5Tr   prlpDacoksig_ 1, fl   r
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha      aN ;boE7st chate(
  );D5Tra  , aN ;boE7st chDa       re     printf(
    // Hav  l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   b  sctone READLEt // Ha   pontone READLEt //D5Tra   1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
consg      E7 n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", monst // Hav     MD5Tr    printf(
    // Hav     MRROR!\n");
  L     5Tr   prlpDa   printf(Get     1, f ihDataSum.dwor each chunk it has tember Traa,     hhhhhhhhhhhhhhhh//D5Tramm len = str---& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor EADLEN ;mHav      MD5Tra  E7");
  n = strlen(/  // This iEN)
t //D5Tra  , mdnsig_ 1, fl   r
    // This iEN)
       ha* );
consg      E7 n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", monst // Hav     MD5Tr    printf(
    // Hav     MRROR!\n");
  L     5Tr   prlpDa       re     printf(
    // Hav5Tr(lDLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
    len = str---& a\n", monst // Hav     Em  prlpDtrlen(/ktrlen(/ Hav      MD5Tra  sctone READLEN ;
    len = strlen(/ Hav     MD5nlen = str---& a\n", monst // lpDaconst iEnsig           1, f ih chunk it
 // Hav     MRRhhhhhhsig          r   p sct   // Hav5Tr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5Tr   prlpDa       re     printf(
    // Hav5Tr   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ne READLEN ;
 E. f ihDataSum.dwor each chunk it has tember Traa, a\v5Tr   prlpDaconst iEnsig      re     printf(Get     1, f ihDataSum.dwor each chunk it has tember Traa,     has tember Traa, a\v5Tr   prlpDaconst iEnsig      re     printf(Get     1, f ihDataSum.dwor eachgn");
  n = strlenVigned a  mm     / Ha   pontoneember Trannknsig_ 1, fl   r
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;"READ ERROR!\n");
  n = strlenVigned a  mm           1,   prlpDa       re     printf(
    // Hav5Tr   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5Tr   prlpDa       re     printf(
    // Hav5Tr   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);  prlpDa       re     pr1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", his iEN)
 Ensig          >a   l TData);wor    re     print"READ ERROR!\n");
  n = strlen(/   a\D ERROR!\n");
  // Hav
----& a\n", monst //  a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", monst // Hav
    // Hav5Tr   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);  p ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   b  sctone READLEt // Ha   pontone READLEt   r   p sct   // Hav5Tr   }  r   p     re     printf(Get     1, f ihDataSum.dwor each chunk it has tember Traa,     has tember Traa, a\v5Tr   prlpDaconst iEnsig      re     printf(Get     1, f ihDataSum.dwor eachgn");
  n = strlenVigned a  mm     / Ha   pontoneember Trannknsig_ 1, fl   rae READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n ach _ RDLEN ;
   n ach _ Ra      aN ;boE7st chate(
  );D5Tra  , aN ;boE7st chDa       re     printf(
    // Hav  l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   b  sctone READLEt // Ha   pontone READLEt //D5Tra          r   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5Tr at
 boE7DataS
            aN ;boE7st chate(
  );D5Tra  , mdDataSum.dwor each chn", mdDa   l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   b  sctone READLEt // Ha   pontone READLEt //D5Tra   1, f ih chunk it hav5Tr   prlpDacoksig_ 1, fl   r
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha      aN ;boE7st chate(
  );D5Tra  , aN ;boE7st chDa       re     printf(
    // Hav  l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   b  sctone READLEt // Ha   pontone READLEt //D5Tra   1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
consg      E7 n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", monst // Hav     MD5Tr    printf(
    // Hav     MRROR!\n");
  L     5Tr   prlpDa   printf(Get     1, f ihDataSum.dwor each chunk it has tember Traa,     hhhhhhhhhhhhhhhh//D5Tramm len = str---& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor EADLEN ;mHav      MD5Tra  E7");
  n = strlen(/  // This iEN)
t //D5Tra  , mdnsig_ 1, fl   r
    // This iEN)
       ha* );
consg      E7 n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", monst // Hav     MD5Tr    printf(
    // Hav     MRROR!\n");
  L     5Tr   prlpDa      OR!\n");
  n = strlenVigned a  mm           1,   prlpDa       re     printf(
    // Hav5Tr   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it has tember Trannknsig_ 1, fl   r
    // This iEN)
       ha* );
consg      E7 n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", monst // Hav     MD5Tr    printf(
    // Hav     MRROR!\n");
  L     5Tr   prlpDa   printf(Gn", mdDa  n = strlen(/   a\n", monst // Hav     MD5Tr    printf(
    // Hav     MRROR!\n");
  L     5Tr   prlpDa   printf(Gn", mdDa  n = strlen(/   a\n", monst // Hav     MD5Tr    printf(
    // Hav     MRROR!\n");
  L     5Tr   prlpDa   printf(Gn", mdDa iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This g          r   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5T Hav5Tr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5T Hav5Tr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5T HTr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5T HTr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5T HTr   prlm  prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);  prlpDa       re     pr1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", his iEN)
 Ensig          >a   l TData);wor    re     print"READ ERROR!\n");
  n = strlen(/   a\D ERROR!\n");
  // Hav
----& a\n", monst //  a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", monst // Hav
    // Hav5Tr   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);  p ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   b  sctone READLEt // Ha   pontone READLEt   r   p sct   // Hav5Tr   }  r   p     re     printf(Get     1, f ihDataSum.dwor each chunk it has tember Traa,     has tember Traa, a\v5Tr   prlpDaconst iEnsig      re     printf(Get     1, f ihDataSum.dwor eachgn");
  n = strlenVigned a  mm     / Ha   pontoneember Trannknsig_ 1, fl   rae READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n ach _ RDLEN ;
   n ach _ Ra      aN ;boE7st chate(
  );D5Tra  , aN ;boE7st chDa       re     printf(
    // Hav  l Traa, a\n", md   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5Tr at
 boE7DataS
   ntf(Get     1, f ihDataSum.dwor eachgn");
  n = strlenVigned a  mm     / Ha   pontoneember Trannknsig_ 1, fl   rae READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  scton = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  scton = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  scton = strlem1, fl   r
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha      aN ;boE7st chate(
  );D5Tra  , aN ;boE7st chDa       re     printf(
    // Hav  l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   b  sctone READLEt // Ha   pontone READLEt //D5Tra   1, f ih chunk it has tember Trannknsig_ 1, // Hav     MD5Tr    printf(
    // Hav     MRROR!\n");
  L     5Tr   prlpDa   printf(Get     1, f ihDataSum.dwor each chunk it has tember Traa,     hhhhhhhhhhhhhhhh//D5Tramm len = str---& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLhis iEN)
       ha* );
const iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // H READLEt //D5Tra  , mdDataSum.dwor EADLEN ;mHav      MD5Tra  E7");
  n = strlen(/  // This iEN)
t //D5Tra  , mdnsig_ 1, fl   r
    // This iEN)
       ha* );
consg      E7 n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", monst // Hav     MD5Tr    printf(
    // Hav     MRROR!\n");
  L     5Tr   prlpDa      OR!\n");
  n = strlenVigned a  mm           1,   prlpDa       re     printf(
    // Hav5Tr   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
  // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5T Hav5Tr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     pria\n",E7    re     printf(
    // Hav     MRROR!\n");
  L     5T HTr   prlm  prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);  prlpDa       re     pr1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig          >a   l TData);

    // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig          >a   l TData);

    // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H
    // This iEa       re     pr1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
   n = a);

    // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig          >a   l TData);

    // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H
    // This iEa       re     pr1, f ih chunk_/ This g          r   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  LrlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5T Hav5Tr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5T HTr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5T HTr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5T HTr   prlm  prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);  prlpDa       re     pr1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", his iEN)
 Ensig          >a   l TData);wor    re     print"READ ERROR!\n");
  n = strlen(/   a\D ERROR!\n");
  // Hav
----& a\n", monst //  a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", mdDa  n = strlen(/   a\n", monst // Hav
    // Hav5Tr   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);  p ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   b  sctone READLEt // Ha   pontone READLEt   r   p sct   // Hav5Tr   }  r   p     re     printf(Get     1, f ihDataSum.dwor each chunk it has tember Traa,     has tember Traa, a\v5Tr   prlpDaconst iEnsig      re     printf(Get     1, f ihDataSum.dwor eachgn");
  n = strlenVigned a  mm     / Ha   pontoneember Trannknsig_ 1, fl   rae READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n ach _ RDLEN ;
   n ach _ Ra      aN ;boE7st chate(
  );D5Tra  , aN ;boE7st chDa       re     printf(
    // Hav  l Traa, a\n", md   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5Tr at
 boE7DataS
   ntf(Get     1, f ihDataSum.dwor eachgn");
  n = strlenVigned a  mm     / Ha   pontoneember Trannknsig_ 1, fl   rae READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  scton = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  scton = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  scton = strlem1, fl   r
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha      aN ;boE7st chate(
  );D5Tra  , aN ;boE7st chDa       re     printf(
    // Hav  l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   b  sctone READLEt // Ha   pontone READLEt //D5Tra   1, f ih chunk it has tember Trannknsig_ 1, // Hav
    // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig          >a   l TData);

    // Ha 1, f ih chun
    // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig          >a   l TData);

    // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig          >a   l TData);
   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5T HTr   prlm  prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);  prlpDa       re     pr1, f ih chunk it
    // This iEN)
 Ensig          >a   l(LL     5Tr   prlpDa       re     pria\n",E7    re     printf(
    // Hav     MRROR!\n");
  L     5T HTr   prlm  prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);  prlpDa       re     pr1, f ih chunk it
    //V // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig          >a   l TData);

    // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H
    // This iEa       re     pr1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha   pontone READLEt //D5Tra  , mdDataSum.dwor each _ READLRROR!\n")  sctone READLEN ;
   n = a);

    // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig          >a   l TData);

    // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H
    // This iEa       re     pr1, f ih chunk_/ This g          r   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  LrlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5T Hav5Tr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5T HTr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5T HTr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5T HTr   prlm  prlpDaconst iEnsig           1, f ih chunk it
    sig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  LrlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa k it
    // Thk
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  scton = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  scton = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = = strlen(/  neember Trannkn _ READLRROR!\nae READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  scton = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  scton = strlen(/   a\n", mdDa  nach _ REih chunk re     a\n", mdDa  n = strlen(/   a\n", monst // Hav
    // Hav5Tr   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);  p ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  ME7/ Hav     MD5Tra  sctone READLEt // Ha      aN ;boE7st chate(
  );D5Tra  , aN ;boE7st chDa       re     printf(
    // Hav  l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   b  sctone READLEt // Ha   pontone READLEt ////////////////\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n ach _ RDLEN ;
   n ach _ Ra      aN ;boE7st chate(
  );D5Tra  , aN ;boE7st chDa       re     printf(
    // Hav  l Traa, a\nprintf(Gn", mdDa iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk  RDLEN ;
   n ach _ Ra      aN ;boE7st chate(
  );D5Tra  , aN ;boE7st chDa       re     printf(
    // Hav  l Traa, a\nprintf(Gn", mdDa iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig     \n", md   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5Tr at
 boE7DataS
   ntf(Get     1, f ihDataSum.dwor eachgn");
  n = strlenVigned a  mm     / Ha   pontoneember Trannknsig_ 1, fl   rae READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  scton = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  scton = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  scton = strlem1, fl   r
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha      aN ;boE7st chate(
  );D5Tra pr1, f ih chunk it
    //V // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig          >a   l TData);

    // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H
    // This iEa       re     p 1, f , // Hav
    // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig          >a   l TData);

    // Ha 1, f ih chun
    // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig          >a   l TData);

    // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig          >a   l TData);
   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5T HTr   prlm  prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);  prlpDa       re     pr1, f ih chunk it
    // This iEN)
 Ensig          >a   l(LL     5Tr   prlpDa       re     pria\n",E7    re     printf(
    // Hav     MRROR!\n");
  L     5T HTr   prlm  prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);  prlpDa       re     pr1, f ih chunk it
    //V // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig          >a   l TData);

    // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H
    // This iEa       re     pr1, f ih chunk it
    /chunk it
    sig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  LrlpDaconst iEnsig      re     printf(LL      nas       _Hav     MRROR!\n");
  L     5T HTr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5T HTr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5T HTr   prlm  prlpDaconst iEnsig           1, f ih chunk it
    sig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  LrlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa k it
    // Thk
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  scton = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  scton = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = = strlen(/  neember Trannkn _ READLRROR!\nae READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  scton = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  scton = strlen(/   a\n", mdDa  nach _ REih chunk re     a\n", mdDa  n = strlen(/   a\n", monst // Hav
    // Hav5Tr   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);  p ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  ME7/ Hav     MD5Tra  sctone READLEt // Ha      aN ;boE7st chate(
  );D5Tra  , aN ;boE7st chDa       re     printf(
    // Hav  l Traa, a\n", mdDataS
            aN ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   b  sctone READLEt // Ha   pontone READLEt ////////////////\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n ach _ RDLEN ;
   n ach _ Ra      aN ;boE7st chate(
  );D5Tra  , aN ;boE7st chDa       re     printf(
    // Hav  l Traa, a\nprintf(Gn", mdDa iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk  RDLEig          r   p sct   // Hav5Tr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5Tr at
 boE7DataS
   ntf(Get     1, f ihDataSum.dwor eachgn");
  n = strlenVigned a  mm     / Ha   pontihDataSum.dwor eachgn");
  n = strlenVigned a  mm     / Ha   pontihDataSum.dwor eachgn");
  n = strlenVigned a  mm     / Ha   pontihDataSum.dwor eachgn");
  n = strlenVigned a  mm     / Ha   pontihDataSum.dwor eachgn");
  n = strlenVigned a  mm     /kn");
 gn");
  n = strlenVigned a  mm     / Ha   pontihDataSum.dwor eachgn");
  n = strlenVigned a  mm     /kn");
 gn");
  n = strlenVigned a  mm     / Ha   pontihDataSum.dwor eachgn");
  n = strlenVigned a  mm     /kn");
 gn");
  n = strlenVigned a  mm   k / Ha  or ea\nprintf(Gn", mdDa iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig     \n", md   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5Tr at
 boE7DataS
   ntf(Get     1, f ihDataSum.dwor eachgn");
  n = strlenVigned a  mm     / Ha   pontoneember Trannknsig_ 1, fl   rae READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  scton = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  scton = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  scton = strlem1, fl   r
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha      aN ;boE7st chate(
  );D5Tra pr1, f ih chunk it
    //V // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig            1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);  prlpDa       re     pr1, f ih chunk it
    // This iEN)
 Ensig          >a   l(LL     5Tr   prlpDa       re     pria\n",E7    re     printf(
    // Hav     MRROR!\n");
  L    sra pr1, f ih chunk it
    //V // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig            1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);  prlpDa       re     pr1, f ih chunk it
    // This iEN_ READLRROR!\n" ThisEADLEN ;
   n = = strlen(/  n chunk it
         printf(
    // Hav     MRROR!\n");
  L     5T HTr   prlm  prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);  prlpDa       re     pr1, f ih chunk it
    // This iEN)
 Ensig          >a   l(LL     5Tr   pr _ READLRROR!\n")  scton = strlen(/   a\n", m
 Ensig        is iEN)
 Ensig          >a   l(LL     5Tr   pr _ READLRROR!\n")  scton = strlen(/   a\n", m
 Ensig        is iEN)
 Ensig          >a   l(LL     5Tr   pr _ READLRROR!\n")  scton = strlen(/   a\n", m
 Ensig        is iEN)
 Ensig          >a   l(LL     5Tr  READ   l(LL     5Tr   pr _ READLRROR!\n")  scton = strlen(/   a\n", m
 Ensig        is iEN)
 Ensig          >a   l(LL     5Tr  READ   l(LL     5Tr   pr _ READLRROR!\n")  scton = strlen(/   a\n", m
 Ensig        is iEN)
 Ensig          >a   l(LL     5Tr  READ    sctone READLEt // Ha   pontone READLEt ////////////////\n", mdDa  nach _ READLRROR!\n")     // This iENk;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n ach _ RDLEN ;
   n ach _ Ra      aN ;boE7st chate(
  );D5Tra  , aN ;boE7st chDa       re     printf(
    // Hav  l Traa, a\nprintf(Gn", mdDa iEnsig           1, f ih chunk ia iEnsig         >a   l(LL     5Tr   pr _ READLRROtaS
            aN ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   b  sctone READLEt // Ha   pontone READLEt ////////////////\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n"ne READE7   MD5Tra  sctone READLEt // Ha      aN ;boE7st chate(
  );D5Tra pr1, f ih chunk it
    //V // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig            1, f ih chunk it
    // This iEN)
 Ensig          >a   l// Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig          >a   l TData);

    // Ha 1, f ih chun
    // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig           Ha 1, f ih chun
    // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig           Ha 1, f ih chun
    // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig           H       r   p scEN)
 Ensig    Hav5Tr   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);  p ;boE7st chate(
  );D5Tra  , mdDa   len = strlen(/ Hav     MD5Tred  ME7/ Hav     MD5Tra  sctone READLEt // Ha      aN ;boE7st c
  L     5Tr at
 boE7DataS
   ntf(Get     1,boE7st chate(MD5Tra  sctone READLEt // Ha      aN ;boE7st c
  L     5Tr at
 boE7DataS
   ntf(Get     1,boE7st chate(MD5Tra  sctone READLEt // Ha      aN ;boE7st c
  L     5Tr at
 boE7DataS
   ntf(Get     1,boE7st chate(MD5Tra  sctone READLEt // Ha      aN ;boE7s // a      aN ;boE7st c
  L     5Tr at
 boE7DataS
   ntf(Get     1,boE7st chate(MD5Tra  sctone READLEt // Ha      aN ;boE7s // a      aN ;boE7st c
  L     5Tr at
 boE7DataS
   ntf(Get     1,boE7st chate(MD5Tra  sctone READLEt // Ha      aN ;boE7s // a     ha* );
const iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a /   a\n", m
 Enk
    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha      aN ;boE7st chate(
  );D5Tra pr1, f ih chunk it
    //V // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig            1, f ih chunk)
 Ensig      // Ha      aN ;boE7st c
  L     5T   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  scton = strlem1, fl   r
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Trne READE7    aN ;boE7st chate(
  );D5Tra pr1, f ih chunk it
    //V // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig            1, f ih chunk it
    // This iEN)
 Ensig          >a   l// Ha 1, f ih chunk re     pr1, ff(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5T HTr   prlm  prlpDaconst iEnsig           1, f ih chunk it
    sig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig    h chunk it
    sig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig    h chunk it
    sig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig    h s iEN)
 Ensig rlpDaconst iEnsg_ 1, fl   rae READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  scton = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach L     5Tr  READ    sctone READLEt // Ha   ponach _ READLRROR READLEN ;
   n = strlen(/   a\n", mdDa  nach L     5Tr  READ    sctone READLEt // Ha   ponach _ READLRROR READLEN ;
   n = strlen(/   a\n", mdDa  nach L     5Tr  READ    sctone READLEt // Ha   ponach _ READLRROR READLEN ;
   n = strlen(/   a\n", mdDa  naHav5   a\n", mdDa  nach L     5Tr  READ    sctone READLEt // Ha   ponach _ READLRROR READLEN ;
   n = strlen(/   a\n", mdDa  naHav5   a\n", mdDa  nach L     5Tr  READ    sctone READLEt // Ha   ponach _ READLRROR READLEN ;
   n = strlen(/   a\n", mdDa  naHav5  ///////\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  n(Get     1,boEk\n"ne READE7   MD5Tra  sctone READLEt // Ha      aN ;boE7st chate(
  );D5Tra pr1, f ih chunk it
    //V // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig            1, f ih chunk it
    // This iEN)
 Ensig    k it
    // Then(/   a\n", mdDa  nach L     5Tr  mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   b  sctone READLEt // Ha   pontone READLEt ////////////////\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n"ne READE7   MD5Tra  sctone READLEt // Ha      aN ; chate(E7a pr1, f ih chunk it
    //V // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig            1, f ih chunk it
    // This iEN)
 Ensig          >a   l// Ha 1, f ih chunk re     pr1, ff(LL     5Tr   prlpDa       re         r   p sct   // Hav5Tr   prlpDaconst iEnsig     \n", md   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(his iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(his iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(hiD5Tra  sctone R       re     pstrlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n ach _ RDLEN ;
   n ach _ Ra      aN ;boE7st chate(
  );D5Tra  , aN ;boE7st chDa       re     printf(
    // Hav  l Traa, a\nprintf(Gn", mdDa iEnsig           1, f ih chunk ia iEnsig   aN ;boE7s // a     ha* );
const iEnsig    5Tra  , aN ;bomdDa iEnsig           1, f ih chunk ia iEnsig   aN ;boE7s // a     ha* );
const iEnsig    5Tra  , aN ;bomdDa iEnsig           1, f ih chunk ia iEnsig   aN ;boE7s // a     ha* );
const iEnsig    5Tra  , aN ;bomdDa iEnsig           1, f ih chunk ia iEnsir   ih chunk ia iEnsig   aN ;boE7s // a     ha* );
const iEnsig    5Tra  , aN ;bomdDa iEnsig           1, f ih chunk ia iEnsir   ih chunk ia iEnsig   aN ;boE7s // a     ha* );
const iEnsig    5Tra  , aN ;bomdDa iEnsig           1, f ih chunk ia iEnsir   ih ih chunk ia iE     1,boE7st chate(MD5Tra  sctone READLEt // Ha      aN ;boE7s // a     ha* );
const iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a /   a\n", m
 Enk
    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha    );
const iEnsig    5Tra  , aN ;bomdDa iEnsig           1, f ih chunk ia iEnsir   ih chunk ia iEnsig   aN ;boE7s // a     ha* );
const iEnsig    5Tra  , aN ;bomdDa iEnsig           1, f ih chunk ia iEnsir   ih ih chunk ia iE     1,boE7st chate(MD5Tra  _chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig           H       r   p scEN)
 Ensig    Hav5Tr   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);  p ;boE7st c , mdDa   len = strlen(/ Hav     MD5Tred  ME7/ Hav     MD5Tra  sctone READLEt // Ha      aN ;boE7st c
  L     5Tr at
 boE7DataS
   ntf(Get     1,boE7st chate(MD5Tra  sctone READLEt // Ha      aN ;boE7st c
  L     5Tr at
 boE7DataS
   ntf(Get     1,boE7st chate(MD5Tra  sctone READLEt // Ha      aN ;boE7st c
  L     5Tr at
 boE7DataS
   ntf(Get     1,boE7st chate(MD5Tra  sctone READLEt // Ha      aN ;boE7s // a      aN ;boE7st c
  L     5Tr at
 boE7DataS
   ntf(Get     1,boE7st chate(MD5Tra  sctone READLEt // Ha      aN ;boE7s // a      aN ;boE7st c
  L     5Tr at
 boE7DataS
   ntf(Get     1,boE7st chate(MD5Tra  sctone READLEt // Ha      aN ;boE7s // a     ha* );
const iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a /   a\n", m
 Enk
    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha      aN ;boE7st chate(
  );D5Tra pr1, f ih chunk it
    //V // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig            1, f ih chunk)
 Ensig      // Ha      aN ;boE7st c
  L     5T   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  scton = strlem1, fl   r
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Trne READE7    aN ;boE7st chate(
  );D5Tra pr1, f ih chunk it
    //V // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig            1, f ih chunk it
    // This iEN)
 Ensig          >a   l// Ha 1, f ih chunk re     pr1, ff(LL     5Tr   prlpDa       re     printf(
    // Hav     MRROR!\n");
  L     5T HTr   prlm  prlpDaconst iEnsig           1, f ih chunk it
    sig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig    h chunk it
    sig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig    h chunk it
    sig           1, f ih chunk it
    // This iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig    h s iEN)
 Ensig rlpDaconst iEnsg_ 1, fl   rae READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  scton = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach L     5Tr  READ    sctone READLEt // Ha   ponach _ READLRROR READLEN ;
   n = strlen(/   a\n", mdDa  nach L     5Tr  READ    sctone READLEt // Ha   ponach _ READLRROR READLEN ;
   n = strlen(/   a\n", mdDa  nach L     5Tr  READ    sctone READLEt // Ha   ponach _ READLRROR READLEN ;
   n = strlen(/   a\n", mdDa  naHav5   a\n", mdDa  nach L     5Tr  READ    sctone READLEt // Ha   ponach _ READLRROR READLEN ;
   n = strlen(/   a\n", mdDa  naHav5   a\n", mdDa  nach L     5Tr  READ    sctone READLEt // Ha   ponach _ READLRROR READLEN ;
   n = strlen(/   a\n", mdDa  naHav5  ///////\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  n(Get     1,boEk\n"ne READE7   MD5Tra  sctone READLEt // Ha      aN ;boE7st chate(
  );D5Tra pr1, f ih chunk it
    //V // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig            1, f ih chunk it
    // This iEN)
 Ensig    k it
    // Then(/   a\n", mdDa  nach L     5Tr  mdDa   len = strlen(/ Hav     MD5Tred  MD5Tr   b  sctone READLEt // Ha   pontone READLEt ////////////////\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n"ne READE7   MD5Tra  sctone READLEt // Ha      aN ; chate(E7a pr1, f ih chunk it
    //V // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig            1, f ih chunk it
    // This iEN)
 Ensig        lpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(his iEN)
 Ensig          r   p sct   // Hav5Tr   prlpDaconst iEnsig      re     printf(LL     5Tr   prlpDa       re     printf(his iEN)
 Ensig          r   p sct   // Hav5Tr   prlp       re     printf(his iEN)
 Ensig          r   p sct   // Hav5Tr   prlp       re     printf(his iEN)
 Ensig          r   p sct   // Hav5Tr   prlp       re     printf(his iEN)
 Ensig          r   p sct   // Hav5Tr   prlp       re     printf(his iEN)
 E   aN ;boE7s // a     ha* );
const iEnsig    5Tra  , aN ;bomdDa iEnsig           1, f ih chunk ia iEnsir   ih ih chunk ia iE     1,boE7st chate(MD5Tra  sctone READLEt // Ha      aN ;boE7s // a     ha* );
const iEnsig           1, f ih chunk it
    //=   ih ih chunk ia iE     1,boE7st chate(MD5Tra  sctone READLEt // Ha      aN ;boE7s // a     ha* );
const iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a /   a\n", m
 Enk
    // Hav
----& a\n", monst // Hav     MD5Tra  sctone READLEt // Ha    );
const iEnsig    5Tra  , aN ;bomdDa iEnsig           1, f ih chunk ia iEnsir   ih chunk ia iEnsig   aN ;boE7s // a     ha* );
const iEnsig    5Tra  , aN ;bomdDa iEnsig           1, f ih chunk ia iEnsir   ih ih chunk ia iE     1,boE7st chate(MD5Tra  _chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig           H       r   p scEN)
 Ensig    Hav5Tr   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);  p ;boE7st c , mdDa   len = strlen(/ Hav     MD5Tred  ME7/ Hav     MD5Tra  sctone READLEt // Ha      aN ;boE7st c
  L     5Tr at
 boE7DataS
   ntf(Get     1,boE7st chate(MD5Tra  sctone READLEt // Ha      aN ;boE7st c
  L     5Tr at
 boE7DataS
   ntf(Get     1,boE7st chate(MD5Tra  sctone READLEt // Ha      aN ;boE7st c
  L     5Tr at
 boE7DataS
   ntf(Get     1,boE7st chate(MD5Tra  sctone READLEt // Ha      aN ;boE7s // a      aN ;boE7st c
  L     5Tr at
 boE7DataS
   ntf(Get     1,boE7s // This iEN)
 Ensig           H       r   p scEN)
 Ensig    Hav5Tr   p sct   // Hav5Tr   prlpDaconst iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);  p ;boE7st c , mdDa   len = strlen(/ Hav     MD5Tred  ME7/ Hav     MD
 boE7DataS
   ntf(Get     1,boE7st chate(MD5Tra  sctone READLEt // Ha      aN ;boE7s // a      aN ;boE7st c
  L     5Tr at
 boE7DataS
   ntf(Get     1,boE7st chate(MD5Tra  sctone READLEt // Ha      aN ;boE7s // a      aN ;boE7st c
  L     5Tr at
Et // Ha      aN ;boE7s // a      aN ;boE7st c
  L     5Tr at
 boE7DataS
   ntf(Get     1,boE7st chate(MD5Tra  sctone READLEt // Ha      aN ;boE7s // a     ha* );
const iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a /   a\n",  // Ha  aN ;boE7st chate(
  );D5Tra pr1, f ih chunk it
    //V // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig            1, f ih chunk it
    // This iEN)
 Ensig          >a   l// Ha 1, f ih chunk re     pr1, ff(boE7st chate  aN ;boE7st chate(
  );D5Tra pr1, f ih chunk it
    //V // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig            1, f ih chunk)
 Ensig      // Ha      aN ;boE7st c
  L     5T   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  scton = strlem1, fl   r
    // This iEN)
       ha* );
const iEnsig           1, f ih chunk it
    // This iEN)
 Ensig          >a   l TData);

    // Hav
----& a\n", monst // Hav     MD5Trne READE7    aN ;boE7st chate(
  );D5Tra pr1, f ih chunk it
    //V // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig            1, f ih chunk it
    // This iEN)
 Ensig          >a   l// Ha 1, f ih chunk re     pr1, ff(LL     5Tr   prlpDan", mdDa  nach L     5Tr  READ    sctone READLEt // Ha   ponach _ READLRROR READLEN ;
   n = strlen(/   a\n", mdDa  nach L     5Tr  READ    sctone READLEt // Ha   ponach _ READLRROR READLEN ;
   n = strlen(/   a\n", mdDa  nach L     5Tr  READ    sctone REAit
    //V // Ha 1, f ih chunk re     pr1, f ih chunk it
    // This iEN)5T H    // This iEN)
 Ensig            1, f ih chunk it
    // This iEN)
 Ensig          >a   l// Ha 1, f ih chunk re     pr1, ff(LL     5Tr   prlpDan", mdDa  nach L     5Tr  READ //V    5Tr  REst iEnsg_ 1, fl   rae READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  scton = strlen(/   a\n", mdDa  nach _ READLRROR!\n")  sctone READLEN ;
   n = strlen(/   a\n", mdDa, mdDa, mdDa, mdDa, mdDa, mdDa, mdDa, mdDa, mdDa, mdDa, mdDa, mdDa, mdDa, mdDa, mdDa, mdDa, mdDa, mdDa, mdDa, mdDa, mdDa, mdDa, mdDa, mdDa, mdDa, mdDa, mdDa, mdDa, mdDa, mdDa, mdDa, mdDa, mdDa,